universal-parcel-scraper 0.232.0-main.1493 → 0.233.0

package/dist/carriers/wanbexpress/adapter.d.ts

@@ -3,6 +3,15 @@ import type { CarrierResult } from '../../core/result/index.js';
 export declare class WanbTracker {
     private readonly environment;
     constructor(environment: AdapterEnvironment);
+    private get endpoint();
+    browserSteps(number: string): {
+        id: string;
+        enabled: boolean;
+        run: ({ signal, remainingMs }: {
+            signal: AbortSignal;
+            remainingMs: number;
+        }) => Promise<CarrierResult>;
+    }[];
     direct(raw: string, context?: TrackingContext): Promise<CarrierResult>;
     private parse;
     browser(raw: string, signal: AbortSignal, remainingMs: number): Promise<CarrierResult>;

package/dist/carriers/wanbexpress/adapter.js

@@ -3,11 +3,19 @@ import { BudgetExceededError, ChallengeError, RateLimitedError, SchemaError, Tra
 import { runSteps } from '../../core/runner/index.js';
 import { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
 import { API, MAX_BYTES, normalizeWanbNumber, ORIGIN, parseWanb, PROVIDER } from './parser.js';
+import { fetchWanbInBrowser } from './browser.js';
 export class WanbTracker {
     environment;
     constructor(environment) {
         this.environment = environment;
     }
+    get endpoint() { return this.environment.env.WANBEXPRESS_BROWSER_WS_ENDPOINT?.trim() || null; }
+    browserSteps(number) {
+        return [
+            { id: 'browser', enabled: !!this.endpoint, run: ({ signal, remainingMs }) => fetchWanbInBrowser(number, this.endpoint, signal, Math.max(1, Math.min(20_000, remainingMs - 2000))) },
+            { id: 'trawl', enabled: !!this.environment.trawl, run: ({ signal, remainingMs }) => this.browser(number, signal, remainingMs) },
+        ];
+    }
     async direct(raw, context = {}) {
         const number = normalizeWanbNumber(raw);
         const { bytes } = await fetchBounded(`${API}?TrackingNumber=${number}`, { signal: context.signal,
@@ -65,20 +73,22 @@ export class WanbTracker {
         const number = normalizeWanbNumber(raw);
         return runSteps({ carrier: 'wanbexpress', budgetMs: context.budgetMs ?? 45000, signal: context.signal, recorder: this.environment.recorder }, [
             { id: 'direct', run: ({ signal, remainingMs }) => this.direct(number, { signal, budgetMs: Math.min(5000, remainingMs) }) },
-            { id: 'trawl', enabled: !!this.environment.trawl, run: ({ signal, remainingMs }) => this.browser(number, signal, remainingMs) },
+            ...this.browserSteps(number),
         ]);
     }
 }
 export const adapter = environment => {
     const tracker = new WanbTracker(environment);
-    return { id: 'wanbexpress', recordsSteps: true, steps: ['direct', 'trawl'], track: (input, context) => tracker.fetch(input.number, context),
+    return { id: 'wanbexpress', recordsSteps: true, steps: ['direct', ...(environment.env.WANBEXPRESS_BROWSER_WS_ENDPOINT?.trim() ? ['browser'] : []), 'trawl'], track: (input, context) => tracker.fetch(input.number, context),
         recognize: (number, context) => recognizeFromLookup(() => tracker.direct(number, context), () => accepted(() => normalizeWanbNumber(number))),
         recognizeWithBrowser: (number, context, previous) => {
             if (previous instanceof SchemaError || previous instanceof RateLimitedError)
                 return Promise.reject(previous);
+            if (!environment.env.WANBEXPRESS_BROWSER_WS_ENDPOINT?.trim() && !environment.trawl)
+                return Promise.reject(new ChallengeError(PROVIDER, 'WanbExpress requires a browser tracking service'));
             return recognizeFromBrowserLookup(() => runSteps({ carrier: 'wanbexpress', budgetMs: context?.budgetMs ?? 45000,
                 signal: context?.signal, recorder: environment.recorder }, [
-                { id: 'trawl', run: ({ signal, remainingMs }) => tracker.browser(number, signal, remainingMs) },
+                ...tracker.browserSteps(normalizeWanbNumber(number)),
             ]));
         } };
 };

package/dist/carriers/wanbexpress/browser.d.ts

@@ -0,0 +1,22 @@
+interface Reply {
+    url: string;
+    status: number;
+    retryAfter: string | null;
+    body: string | null;
+    truncated: boolean;
+}
+interface GuestResult {
+    replies: Reply[];
+    verification?: {
+        status: number;
+        retryAfter: string | null;
+    };
+}
+/** Runs in the carrier page. CAPTCHA credentials never leave this function. */
+export declare function wanbGuestFlow({ number, timeoutMs, maxBytes }: {
+    number: string;
+    timeoutMs: number;
+    maxBytes: number;
+}): Promise<GuestResult>;
+export declare function fetchWanbInBrowser(number: string, endpoint: string, signal: AbortSignal, timeoutMs: number): Promise<import("../../index.js").CarrierResult>;
+export {};

package/dist/carriers/wanbexpress/browser.js

@@ -0,0 +1,142 @@
+import { ChallengeError, RateLimitedError, SchemaError, TransportError, UpstreamHttpError } from '../../core/errors/index.js';
+import { withRemoteBrowser } from '../../core/transport/localBrowser.js';
+import { API, MAX_BYTES, ORIGIN, parseWanb, PROVIDER } from './parser.js';
+/** Runs in the carrier page. CAPTCHA credentials never leave this function. */
+export async function wanbGuestFlow({ number, timeoutMs, maxBytes }) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const result = { replies: [] };
+    const body = async (response) => {
+        if (Number(response.headers.get('content-length')) > maxBytes) {
+            void response.body?.cancel().catch(() => { });
+            return { body: null, truncated: true };
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            return { body: '', truncated: false };
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const part = await reader.read();
+                if (part.done)
+                    break;
+                size += part.value.length;
+                if (size > maxBytes) {
+                    void reader.cancel().catch(() => { });
+                    return { body: null, truncated: true };
+                }
+                chunks.push(part.value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return { body: new TextDecoder().decode(bytes), truncated: false };
+    };
+    const track = async () => {
+        const response = await fetch('/TrackPoints/Track?TrackingNumber=' + encodeURIComponent(number), { credentials: 'same-origin', signal });
+        const reply = { url: response.url, status: response.status, retryAfter: response.headers.get('retry-after'), body: null, truncated: false };
+        result.replies.push(reply);
+        if (response.status === 200)
+            Object.assign(reply, await body(response));
+        else
+            void response.body?.cancel().catch(() => { });
+        return reply;
+    };
+    const first = await track();
+    if (first.status !== 200 || !first.body || first.truncated)
+        return result;
+    const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+    let initial;
+    try {
+        initial = JSON.parse(first.body);
+    }
+    catch {
+        return result;
+    }
+    if (!record(initial) || initial.Succeeded !== false || !record(initial.Error) || initial.Error.Code !== '0x110012')
+        return result;
+    const version = document.querySelector('#showCaptchaVersion')?.value;
+    const key = document.querySelector('#sitekey')?.value;
+    if (version !== 'V3' || !/^[A-Za-z0-9_-]{30,100}$/.test(key ?? ''))
+        return result;
+    const win = window;
+    try {
+        delete win.grecaptcha;
+        delete win.___grecaptcha_cfg;
+        await new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = 'https://www.recaptcha.net/recaptcha/api.js?render=' + encodeURIComponent(key);
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error('Verification script unavailable'));
+            document.head.appendChild(script);
+        });
+        await new Promise(resolve => win.grecaptcha.ready(resolve));
+        const token = await win.grecaptcha.execute(key, { action: 'submit' });
+        signal.throwIfAborted();
+        const response = await fetch('/Home/CaptchaVerify?token=' + encodeURIComponent(token) + '&version=V3', { credentials: 'same-origin', signal });
+        result.verification = { status: response.status, retryAfter: response.headers.get('retry-after') };
+        if (response.status !== 200) {
+            void response.body?.cancel().catch(() => { });
+            return result;
+        }
+        const verification = await body(response);
+        if (!verification.truncated && verification.body) {
+            const accepted = JSON.parse(verification.body);
+            if (record(accepted) && accepted.Succeeded === true)
+                await track();
+        }
+    }
+    catch { /* The initial rejection remains authoritative when verification cannot complete. */ }
+    return result;
+}
+function checkStatus(status, retryAfter) {
+    if ([401, 403, 428].includes(status))
+        throw new ChallengeError(PROVIDER);
+    if (status === 429) {
+        const delay = retryAfter && /^\d+$/.test(retryAfter) ? Number(retryAfter) * 1000 : retryAfter ? Date.parse(retryAfter) - Date.now() : NaN;
+        throw new RateLimitedError(PROVIDER, Number.isFinite(delay) ? Math.max(0, delay) : undefined);
+    }
+    if (status >= 500)
+        throw new UpstreamHttpError(PROVIDER, status);
+    if (status >= 400)
+        throw new TransportError(PROVIDER, 'WanbExpress browser endpoint is unavailable', { status });
+}
+export function fetchWanbInBrowser(number, endpoint, signal, timeoutMs) {
+    return withRemoteBrowser({ provider: PROVIDER, endpoint, signal, timeoutMs }, async ({ browser, signal: stopped, remainingMs }) => {
+        const context = await browser.newContext({ acceptDownloads: false });
+        const page = await context.newPage();
+        const navigation = await page.goto(`${ORIGIN}/`, { waitUntil: 'domcontentloaded', timeout: Math.min(10_000, remainingMs()) });
+        if (!navigation)
+            throw new TransportError(PROVIDER, 'WanbExpress tracking page is unavailable');
+        checkStatus(navigation.status(), navigation.headers()['retry-after'] ?? null);
+        if (navigation.status() !== 200 || new URL(navigation.url()).origin !== ORIGIN)
+            throw new SchemaError(PROVIDER, 'WanbExpress returned an unexpected tracking page');
+        const result = await page.evaluate(wanbGuestFlow, { number, timeoutMs: remainingMs(), maxBytes: MAX_BYTES });
+        stopped.throwIfAborted();
+        if (result.verification)
+            checkStatus(result.verification.status, result.verification.retryAfter);
+        const reply = result.replies.at(-1);
+        if (!reply || result.replies.length > 2 || reply.url !== `${API}?TrackingNumber=${encodeURIComponent(number)}`)
+            throw new SchemaError(PROVIDER, 'WanbExpress returned an unrelated browser response');
+        checkStatus(reply.status, reply.retryAfter);
+        if (reply.truncated || reply.body === null)
+            throw new TransportError(PROVIDER, 'WanbExpress returned an incomplete browser response');
+        if (reply.status !== 200)
+            throw new SchemaError(PROVIDER);
+        let payload;
+        try {
+            payload = JSON.parse(reply.body);
+        }
+        catch {
+            throw new SchemaError(PROVIDER, 'WanbExpress returned invalid browser JSON');
+        }
+        return parseWanb(payload, number);
+    });
+}

package/dist/carriers/wanbexpress/carrier.json

@@ -21,6 +21,7 @@
     "adapter": "wanbexpress",
     "steps": [
       "direct",
+      "browser",
       "trawl"
     ],
     "recognition": {

package/dist/server/openapi.json

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

package/package.json

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