main.js

'use strict';

/*
 * Created with @iobroker/create-adapter v2.0.2
 */

// The adapter-core module gives you access to the core ioBroker functions
// you need to create an adapter

const utils = require('@iobroker/adapter-core');
const axios = require('axios').default;
const qs = require('qs');
const crypto = require('crypto');
const Json2iob = require('json2iob');
const getPwd = require('./lib/rsaKey');
const tough = require('tough-cookie');
const { HttpsCookieAgent } = require('http-cookie-agent/http');
const { JSDOM } = require('jsdom');
const fs = require('fs');
const { sep } = require('path');
const { tmpdir } = require('os');

const dhlDecrypt = require('./lib/dhldecrypt');
const { loginDhlNew: dhlLoginNew } = require('./lib/dhlLogin');
const { loginDPD: dpdLoginSoap, fetchDPDParcels: dpdFetchParcels } = require('./lib/dpdLogin');
const { classifyGlsDeliveryStatus } = require('./lib/glsStatus');
class Parcel extends utils.Adapter {
  /**
   * @param {Partial<utils.AdapterOptions>} [options={}]
   */
  constructor(options) {
    super({
      ...options,
      name: 'parcel',
    });
    this.on('ready', this.onReady.bind(this));
    this.on('stateChange', this.onStateChange.bind(this));
    this.on('unload', this.onUnload.bind(this));

    this.json2iob = new Json2iob(this);
    this.sessions = {};
    this.mergedJson = [];
    this.inDelivery = [];
    this.notDelivered = [];
    this.mergedJsonObject = {};
    this.images = {};
    this.alreadySentMessages = {};
    this.ignoredPath = [];
    this.firstStart = true;
    this.delivery_status = {
      ERROR: -1,
      UNKNOWN: 5,
      REGISTERED: 10,
      IN_PREPARATION: 20,
      IN_TRANSIT: 30,
      OUT_FOR_DELIVERY: 40,
      DELIVERED: 1,
    };
    this.tmpDir = tmpdir();
    this.requestClient = axios.create();
  }

  /**
   * Is called when databases are connected and adapter received configuration.
   */
  async onReady() {
    // Reset the connection indicator during startup
    this.setState('info.connection', false, true);
    if (this.config.interval < 0.5) {
      this.log.info('Set interval to minimum 0.5');
      this.config.interval = 0.5;
    }

    this.cookieJar = new tough.CookieJar();
    const cookieState = await this.getStateAsync('auth.cookie');
    if (cookieState && cookieState.val) {
      this.cookieJar = tough.CookieJar.fromJSON(cookieState.val);
    }
    this.requestClient = axios.create({
      withCredentials: true,

      httpsAgent: new HttpsCookieAgent({ cookies: { jar: this.cookieJar }, rejectUnauthorized: false }),
    });
    // Reichere jeden axios-Fehler mit Method/URL/Status an, sonst kommen im Log
    // nur nichtssagende "Error: read ECONNRESET"-Zeilen an.
    this.requestClient.interceptors.response.use(
      (res) => res,
      (error) => {
        try {
          const cfg = error.config || {};
          const method = (cfg.method || 'GET').toUpperCase();
          const url = cfg.url || '';
          const status = error.response && error.response.status;
          const code = error.code || (status ? `HTTP ${status}` : 'NO_RESPONSE');
          const msg = error.message || 'unknown';
          error.contextInfo = `${method} ${url} → ${code} (${msg})`;
        } catch {
          // don't obscure the original error if annotation fails
        }
        return Promise.reject(error);
      },
    );
    if (this.config.amzActive !== false && this.config.amzusername && this.config.amzpassword) {
      this.log.info('Login to Amazon');
      await this.loginAmz();
    }

    if (this.config.dhlActive !== false) {
      if (this.config.dhlCode && this.config.dhlCode.startsWith('dhllogin://')) {
        this.log.info('Login to DHL via new dhllogin:// code');
        await this.loginDhlNew();
      } else {
        const dhlSessionState = await this.getStateAsync('auth.dhlSession');
        if (dhlSessionState && dhlSessionState.val) {
          this.log.info('Use existing DHL session. If this fails please delete auth.dhlSession');
          this.sessions['dhl'] = JSON.parse(String(dhlSessionState.val));
          await this.refreshToken();
          await this.createDHLStates();
        }
      }
    }

    if (this.config.dpdActive !== false && this.config.dpdusername && this.config.dpdpassword) {
      const dpdSessionState = await this.getStateAsync('auth.dpdSession');
      if (dpdSessionState && dpdSessionState.val) {
        try {
          const parsed = JSON.parse(String(dpdSessionState.val));
          if (parsed && parsed.SessionToken && parsed.cloudUserID != null) {
            this.log.info('Reuse existing DPD session (SessionFullState will verify).');
            this.sessions['dpd'] = parsed;
          }
        } catch {
          // fall through to fresh login
        }
      }
      if (!this.sessions['dpd']) {
        this.log.info('Login to DPD');
        await this.loginDPD();
      }
    }
    if (this.config.t17Active !== false && this.config.t17username && this.config.t17password) {
      this.log.info('Login to T17 User');
      await this.login17T();
    }
    if (this.config.aliUsername && this.config.aliPassword) {
      this.log.info('Login to AliExpres');
      await this.loginAli();
    }

    if (this.config.t17ApiActive !== false && this.config['17trackKey']) {
      this.sessions['17track'] = this.config['17trackKey'];
      this.login17TApi();
      this.setState('info.connection', true, true);
    }

    if (this.config.glsActive !== false && this.config.glsusername && this.config.glspassword) {
      const glsSessionState = await this.getStateAsync('auth.glsSession');
      if (glsSessionState && glsSessionState.val) {
        try {
          const parsed = JSON.parse(String(glsSessionState.val));
          if (parsed && parsed.refresh_token) {
            this.log.info('Reuse existing GLS session, refresh token…');
            this.sessions['gls'] = parsed;
            this.glstoken = parsed.access_token;
            await this.refreshGLSToken();
          }
        } catch {
          // fall through to fresh login
        }
      }
      if (!this.sessions['gls']) {
        this.log.info('Login to GLS');
        await this.loginGLS();
      }
    }
    if (this.config.upsActive !== false && this.config.upsusername && this.config.upspassword) {
      this.log.info('Login to UPS');
      await this.loginUPS();
    }
    if (this.config.hermesActive !== false && this.config.hermesusername && this.config.hermespassword) {
      this.log.info('Login to Hermes');
      await this.loginHermes();
    }

    this.updateInterval = null;
    this.reLoginTimeout = null;
    this.refreshTokenTimeout = null;
    this.subscribeStates('*');

    if (Object.keys(this.sessions).length > 0) {
      this.log.debug('Starting updateProvider with sessions: ' + JSON.stringify(Object.keys(this.sessions)));
      await this.updateProvider();
      this.updateInterval = setInterval(async () => {
        this.firstStart = false;
        await this.updateProvider();
      }, this.config.interval * 60 * 1000);
      this.refreshTokenInterval = setInterval(() => {
        this.refreshToken();
      }, 29 * 60 * 1000);
    } else {
      this.log.warn('No login session found');
    }
  }
  async loginDhlNew() {
    const sessionData = await dhlLoginNew({
      requestClient: this.requestClient.bind(this),
      dhlCode: this.config.dhlCode,
      log: this.log,
    });
    if (!sessionData) {
      return;
    }
    this.sessions['dhl'] = sessionData;
    await this.cookieJar.setCookie('dhli=' + sessionData.id_token + '; path=/; domain=dhl.de', 'https:/dhl.de');
    await this.cookieJar.setCookie('dhli=' + sessionData.id_token + '; path=/; domain=www.dhl.de', 'https:/www.dhl.de');
    this.setState('info.connection', true, true);
    this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
    await this.createDHLStates();
    await this.extendObject('auth.dhlSession', {
      type: 'state',
      common: {
        name: 'DHL Session',
        type: 'string',
        role: 'json',
        read: true,
        write: false,
      },
      native: {},
    });
    this.setState('auth.dhlSession', JSON.stringify(sessionData), true);
    this.dhlLoginSuccess = true;
  }
  /**
   * Loggt einen HTTP-Fehler mit Kontext (Provider, Method, URL, Status, Body-Preview).
   * Ersatz für die vielen `this.log.error(error)`-Stellen, die sonst nur nichtssagende
   * "Error: read ECONNRESET"-Zeilen produzieren.
   *
   * Erkennt automatisch, ob es sich um einen echten Axios-Fehler (mit `.config` oder
   * `.response`) oder um einen normalen JS-Error (JSON.parse, DOM, IO) handelt und
   * gibt entsprechend den vollen HTTP-Kontext oder nur Message + Stack aus. So
   * werden Parse-/State-Exceptions nicht mehr fälschlich als "GET  → NO_RESPONSE"
   * geloggt.
   *
   * @param {string} scope - Provider-Kürzel bzw. Ort, z.B. "GLS/login" oder "DHL/fetch"
   * @param {any} error - der geworfene Fehler
   */
  logAxiosError(scope, error) {
    if (!error) {
      this.log.error(`[${scope}] Unknown error (falsy)`);
      return;
    }
    const isAxiosError = !!(error.config || error.response || error.request || error.isAxiosError);
    if (!isAxiosError) {
      this.log.error(`[${scope}] ${error.message || String(error)}`);
      if (this.log.debug && error.stack) {
        this.log.debug(`[${scope}] stack: ${error.stack}`);
      }
      return;
    }
    const cfg = (error.config || {});
    const method = (cfg.method || 'GET').toUpperCase();
    const url = cfg.url || '';
    const status = error.response && error.response.status;
    const code = error.code || (status ? `HTTP ${status}` : 'NO_RESPONSE');
    const msg = error.message || 'unknown';
    this.log.error(`[${scope}] ${method} ${url} → ${code} (${msg})`);
    if (error.response && error.response.data) {
      let body = error.response.data;
      if (typeof body !== 'string') {
        try { body = JSON.stringify(body); } catch { body = String(body); }
      }
      if (body && body.length) {
        this.log.error(`[${scope}] body: ${body.length > 500 ? body.slice(0, 500) + '…' : body}`);
      }
    }
    if (this.log.debug && error.stack) {
      this.log.debug(`[${scope}] stack: ${error.stack}`);
    }
  }
  async loginAli() {
    const loginData = await this.requestClient({
      method: 'get',
      url: 'https://passport.aliexpress.com/mini_login.htm?lang=de_de&appName=aebuyer&appEntrance=default&styleType=auto&bizParams=&notLoadSsoView=false&notKeepLogin=false&isMobile=false&cssLink=https://i.alicdn.com/noah-static/4.0.2/common/css/reset-havana.css&cssUrl=https://i.alicdn.com/noah-static/4.0.2/common/css/reset-havana-new-page.css&showMobilePwdLogin=false&defaultCountryCode=DE&ut=&rnd=0.9085151696364684',
      headers: {
        'sec-ch-ua': '" Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"macOS"',
        'upgrade-insecure-requests': '1',
        'user-agent':
          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.20 Safari/537.36',
        accept:
          'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
        'sec-fetch-site': 'same-site',
        'sec-fetch-mode': 'navigate',
        'sec-fetch-dest': 'iframe',
        referer: 'https://login.aliexpress.com/',
        'accept-language': 'de',
      },
    })
      .then(async (res) => {
        this.log.debug(JSON.stringify(res.data));
        if (res.data.indexOf('window.viewData = ') !== -1) {
          try {
            const loginData = res.data.split('window.viewData = ')[1].split(';')[0].replace(/\\/g, '');
            return JSON.parse(loginData).loginFormData;
          } catch (error) {
            this.logAxiosError('AliExpress/login', error);
          }
        } else {
          this.log.error('Failed Step 1 Aliexpress');
        }
      })
      .catch((error) => {
        this.logAxiosError('AliExpress/login', error);
        if (error.response) {
          this.log.error(JSON.stringify(error.response.data));
        }
      });

    if (!loginData) {
      return;
    }
    if (!this.config.aliMfa) {
      loginData.loginId = this.config.aliUsername;
      loginData.password2 = getPwd(this.config.aliPassword);
      await this.requestClient({
        method: 'post',
        url: 'https://passport.aliexpress.com/newlogin/login.do?appName=aebuyer&fromSite=13&_bx-v=2.0.39',
        headers: {
          'sec-ch-ua': '" Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"',
          accept: 'application/json, text/plain, */*',
          'content-type': 'application/x-www-form-urlencoded',
          'sec-ch-ua-mobile': '?0',
          'user-agent':
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.20 Safari/537.36',
          'sec-ch-ua-platform': '"macOS"',
          origin: 'https://login.aliexpress.com',
          'sec-fetch-site': 'same-site',
          'sec-fetch-mode': 'cors',
          'sec-fetch-dest': 'empty',
          referer: 'https://login.aliexpress.com/',
          'accept-language': 'de',
        },

        data: qs.stringify(loginData),
      })
        .then(async (res) => {
          if (res.data.url && res.data.url.indexOf('punish') !== -1) {
            this.log.error('Failed because of captcha');
          }
          //  this.log.debug(JSON.stringify(res.data));
        })
        .catch((error) => {
          this.logAxiosError('AliExpress/login', error);
          if (error.response) {
            this.log.error(JSON.stringify(error.response.data));
          }
        });
      await this.requestClient({
        method: 'get',
        url: 'https://www.aliexpress.com/p/order/index.html',
      })
        .then(async (res) => {
          //  this.log.debug(JSON.stringify(res.data));
          res.data.indexOf('Session has expired') !== -1
            ? this.log.error('Session has expired')
            : this.log.info('Login to Aliexpress successful');
        })
        .catch(async (error) => {
          this.logAxiosError('AliExpress/verify', error);
        });
    } else {
      this.log.warn('AliExpress MFA login is not supported');
    }
  }

  async loginAmz() {
    await this.setObjectNotExistsAsync('amazon', {
      type: 'device',
      common: {
        name: 'Amazon Tracking',
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('amazon.json', {
      type: 'state',
      common: {
        name: 'Json Sendungen',
        write: false,
        read: true,
        type: 'string',
        role: 'json',
      },
      native: {},
    });

    // Check if we have a pending verification code to submit
    const verificationState = await this.getStateAsync('auth.amzVerification');
    if (verificationState && verificationState.val && this.config.amzotp) {
      this.log.info('Found pending Amazon verification. Submitting code...');
      try {
        const verification = JSON.parse(verificationState.val);
        const form = verification.form;
        form['code'] = this.config.amzotp;
        form['action'] = 'code';
        this.log.debug('Verify URL: ' + verification.url);
        this.log.debug('Verify form: ' + JSON.stringify(form));

        const verifyResult = await this.requestClient({
          method: 'post',
          url: verification.url,
          headers: {
            'content-type': 'application/x-www-form-urlencoded',
            accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            origin: 'https://www.amazon.de',
            'accept-language': 'de-DE,de;q=0.9',
            'user-agent':
              'Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
            referer: verification.url,
          },
          data: qs.stringify(form),
        });

        await this.setStateAsync('auth.amzVerification', '', true);

        if (verifyResult.data && verifyResult.data.indexOf('js-yo-main-content') !== -1) {
          this.log.info('Amazon verification successful');
          this.sessions['amz'] = true;
          this.setState('info.connection', true, true);
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          return;
        }
        if (verifyResult.data && verifyResult.data.indexOf('order') !== -1) {
          this.log.info('Amazon verification successful');
          this.sessions['amz'] = true;
          this.setState('info.connection', true, true);
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          return;
        }
        this.log.error('Amazon verification code was not accepted. Please restart and try again.');
        this.log.debug(verifyResult.data);
      } catch (error) {
        this.log.error('Failed to submit Amazon verification code');
        this.logAxiosError('Amazon/login', error);
        if (error.response) {
          this.log.debug('Verification error response: ' + (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data)));
        }
        await this.setStateAsync('auth.amzVerification', '', true);
        try {
          delete this.cookieJar.store.idx['amazon.de'];
          delete this.cookieJar.store.idx['www.amazon.de'];
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          this.log.info('Amazon Cookies gelöscht. Bitte Adapter neu starten.');
        } catch { /* ignore */ }
      }
      return;
    }

    // Clear old Amazon cookies if user requested it (login problems)
    if (this.config.amzResetCookies) {
      this.log.info('Amazon Cookies werden gelöscht (Option in Einstellungen)');
      try {
        delete this.cookieJar.store.idx['amazon.de'];
        delete this.cookieJar.store.idx['www.amazon.de'];
        this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
      } catch { /* ignore */ }
    }

    let amzResponseUrl = '';
    let body = await this.requestClient({
      method: 'get',
      maxBodyLength: Infinity,
      url: 'https://www.amazon.de/ap/signin?_encoding=UTF8&accountStatusPolicy=P1&openid.assoc_handle=deflex&openid.claimed_id=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0%2Fidentifier_select&openid.identity=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0%2Fidentifier_select&openid.mode=checkid_setup&openid.ns=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0&openid.ns.pape=http%3A%2F%2Fspecs.openid.net%2Fextensions%2Fpape%2F1.0&openid.pape.max_auth_age=0&openid.return_to=https%3A%2F%2Fwww.amazon.de%2Fgp%2Fcss%2Forder-history%3Fie%3DUTF8%26ref_%3Dnav_orders_first&pageId=webcs-yourorder&showRmrMe=1',
      headers: {
        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept-charset': 'utf-8',
        'sec-fetch-site': 'none',
        'accept-language': 'de-DE,de;q=0.9',
        'cache-control': 'no-store',
        'sec-fetch-mode': 'navigate',
        'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
      },
    })
      .then(async (res) => {
        amzResponseUrl = res.request?.res?.responseUrl || res.request?.responseURL || '';
        this.log.debug('Amazon signin response URL: ' + amzResponseUrl);
        this.log.debug(JSON.stringify(res.data));
        return res.data;
      })
      .catch((error) => {
        this.log.error('Amazon first login step failed');
        this.log.error(
          'https://www.amazon.de/ap/signin?openid.return_to=https://www.amazon.de/ap/maplanding&openid.oa2.code_challenge_method=S256&openid.assoc_handle=amzn_mshop_ios_v2_de&openid.identity=http://specs.openid.net/auth/2.0/identifier_select&pageId=amzn_mshop_ios_v2_de&openid.ns.oa2=http://www.amazon.com/ap/ext/oauth/2&openid.claimed_id=http://specs.openid.net/auth/2.0/identifier_select&openid.mode=checkid_setup&openid.oa2.client_id=device:42334146314239333737364334463941393135443746313136363446434238302341334e5748585451344542435a53&openid.oa2.code_challenge=ig2YgHP3AoncuKG0ks5pgr1HUhzwvlST-tuIY2Chi2M&openid.ns.pape=http://specs.openid.net/extensions/pape/1.0&openid.oa2.scope=device_auth_access&openid.ns=http://specs.openid.net/auth/2.0&openid.pape.max_auth_age=0&openid.oa2.response_type=code',
        );
        this.logAxiosError('Amazon/login', error);
        if (error.response) {
          this.log.error(JSON.stringify(error.response.data));
        }
      });
    if (body && body.indexOf('untrusted-app-sign-in-continue-button-announce') !== -1) {
      this.log.info('Amazon untrustet app warning detected');
      const form = this.extractHidden(body);
      delete form['sessionChallengeAck'];
      delete form['ue_back'];
      delete form['undefined'];
      body = await this.requestClient({
        method: 'post',
        maxBodyLength: Infinity,
        url: 'https://www.amazon.de/ap/signin',
        headers: {
          accept:
            'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
          'accept-language': 'de',
          'cache-control': 'no-cache',
          'content-type': 'application/x-www-form-urlencoded',
        },
        data: form,
      })
        .then(async (res) => {
          this.log.debug(JSON.stringify(res.data));
          if (res.data.indexOf('/errors/validateCaptcha') !== -1) {
            this.log.error('Captcha detected');
            return;
          }
          return res.data;
        })
        .catch((error) => {
          this.log.error('Amazon untrustet app warning failed');
          this.logAxiosError('Amazon/login', error);
          if (error.response) {
            this.log.error(JSON.stringify(error.response.data));
          }
        });
    }
    let form = this.extractHidden(body);
    let postUrl = this.extractFormAction(body) || amzResponseUrl || 'https://www.amazon.de/ap/signin';

    // Handle Unified Claim Collection page (new Amazon login flow)
    // Keep ALL fields, add email, POST to get password page, then continue with password POST.
    if (form.appAction === 'SIGNIN_CLAIM_COLLECT' || (body && body.indexOf('FullPageUnifiedClaimCollect') !== -1)) {
      this.log.info('Amazon Unified Claim Collection page detected');
      // Extract any form action (not just name="signIn")
      const anyFormAction = body.match(/<form[^>]*action=["']([^"']*)["']/i);
      if (anyFormAction) {
        let actionUrl = anyFormAction[1].replace(/&amp;/g, '&');
        if (actionUrl.startsWith('/')) actionUrl = 'https://www.amazon.de' + actionUrl;
        postUrl = actionUrl;
      }
      // Remove only webAuthn and ue_back, keep everything else
      delete form['webAuthnGetArbForAutofill'];
      delete form['webAuthnGetParametersForAutofill'];
      delete form['webAuthnChallengeIdForAutofill'];
      delete form['ue_back'];
      delete form['undefined'];
      form.email = this.config.amzusername;
      this.log.debug('Unified Claim Collection POST to: ' + postUrl);

      body = await this.requestClient({
        method: 'post',
        maxBodyLength: Infinity,
        url: postUrl,
        headers: {
          'content-type': 'application/x-www-form-urlencoded',
          accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
          'sec-fetch-site': 'same-origin',
          'accept-language': 'de-DE,de;q=0.9',
          'sec-fetch-mode': 'navigate',
          origin: 'https://www.amazon.de',
          'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
          referer: postUrl,
        },
        data: qs.stringify(form),
      })
        .then(async (res) => {
          amzResponseUrl = res.request?.res?.responseUrl || res.request?.responseURL || amzResponseUrl;
          this.log.debug('Unified email POST successful. Response URL: ' + amzResponseUrl);
          return res.data;
        })
        .catch((error) => {
          this.log.error('Unified email POST failed');
          this.logAxiosError('Amazon/login', error);
          if (error.response) {
            this.log.error(JSON.stringify(error.response.data));
          }
          return null;
        });
      if (!body) return;
      form = this.extractHidden(body);
      postUrl = this.extractFormAction(body) || amzResponseUrl || postUrl;
      this.log.debug('After Unified email POST - postUrl: ' + postUrl);
    }

    // ax/claim: email-only page (2-step). ap/signin: email+password on same page.
    // Detect by checking if body contains a visible password input field
    const isTwoStep = body.indexOf('type="password"') === -1;
    if (isTwoStep && form.email !== this.config.amzusername) {
      form.email = this.config.amzusername;
      body = await this.requestClient({
        method: 'post',
        maxBodyLength: Infinity,
        url: postUrl,
        headers: {
          'content-type': 'application/x-www-form-urlencoded',
          accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
          'sec-fetch-site': 'same-origin',
          'accept-language': 'de-DE,de;q=0.9',
          'sec-fetch-mode': 'navigate',
          origin: 'https://www.amazon.de',
          'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
          referer: postUrl,
          'sec-fetch-dest': 'document',
        },
        data: qs.stringify(form),
      })
        .then(async (res) => {
          this.log.silly(JSON.stringify(res.data));
          this.log.debug('Username successfully posted');
          const form = this.extractHidden(res.data);
          if (Object.keys(form).length <= 3) {
            this.log.error('Password form too short');
            this.log.error(res.data);
          }
          return res.data;
        })
        .catch((error) => {
          this.log.error('Failed to post username');
          this.logAxiosError('Amazon/login', error);
          if (error.response) {
            this.log.error(JSON.stringify(error.response.data));
          }
          try {
            delete this.cookieJar.store.idx['amazon.de'];
            delete this.cookieJar.store.idx['www.amazon.de'];
            this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
            this.log.info('Amazon Cookies gelöscht nach Login-Fehler. Bitte Adapter neu starten.');
          } catch { /* ignore */ }
        });
      form = this.extractHidden(body);
      postUrl = this.extractFormAction(body) || postUrl;
    }
    delete form['='];
    delete form['undefined'];
    this.log.debug('Post form : ' + JSON.stringify(form));

    form.rememberMe = 'true';
    form.password = this.config.amzpassword;
    this.log.debug('Post with password');
    await this.requestClient({
      method: 'post',
      url: postUrl,
      headers: {
        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'content-type': 'application/x-www-form-urlencoded',
        origin: 'https://www.amazon.de',
        'accept-language': 'de-de',
        'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_8 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
        referer: postUrl,
      },
      data: form,
    })
      .then(async (res) => {
        this.log.silly(JSON.stringify(res.data));
        this.log.debug('Password successfully posted');
        if (res.data.indexOf('js-yo-main-content') !== -1) {
          this.log.info('Relogin to Amazon successful');
          this.sessions['amz'] = true;
          this.setState('info.connection', true, true);
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);

          return;
        }
        if (res.data.indexOf('auth-mfa-otpcode') !== -1) {
          this.log.info('Found MFA token login');
          const form = this.extractHidden(res.data);
          // delete form['ue_back'];
          // delete form['sessionChallengeAck'];
          delete form['undefined'];
          form.deviceId = form.deviceId || '';
          form.otpCode = this.config.amzotp;
          form.rememberDevice = true;

          await this.requestClient({
            method: 'post',
            url: 'https://www.amazon.de/ap/signin',
            headers: {
              'content-type': 'application/x-www-form-urlencoded',
              accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
              'sec-fetch-site': 'same-origin',
              'accept-language': 'de-DE,de;q=0.9',
              'sec-fetch-mode': 'navigate',
              origin: 'https://www.amazon.de',
              'user-agent':
                'Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
              referer: 'https://' + res.request.host + res.request.path,
              'sec-fetch-dest': 'document',
            },
            data: qs.stringify(form),
          })
            .then(async (res) => {
              this.log.silly(JSON.stringify(res.data));
              this.log.debug('MFA successfully posted');
              if (res.data.indexOf('js-yo-main-content') !== -1) {
                this.log.info('Login to Amazon successful');
                this.sessions['amz'] = true;
                this.setState('info.connection', true, true);
                this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
                await this.setObjectNotExistsAsync('amazon', {
                  type: 'device',
                  common: {
                    name: 'Amazon Tracking',
                  },
                  native: {},
                });
                return;
              }
              this.log.error(
                'MFA: Login to Amazon failed. Enter correct MFA Code from SMS or App. Or check you account and login manually to Amazon',
              );
              this.setState('info.connection', false, true);
            })
            .catch(async (error) => {
              this.log.error('MFA: Failed to post https://www.amazon.de/ap/signin');
              if (error.response) {
                this.setState('info.connection', false, true);
                this.log.error(JSON.stringify(error.response.data));
              }

              this.logAxiosError('Amazon/login', error);
            });
          return;
        }
        if (res.data.indexOf('Amazon Anmelden') !== -1) {
          this.log.error('Login to Amazon failed, please login to Amazon manually and check the login');
          if (res.data.indexOf('captcha-placeholder') !== -1) {
            this.log.warn(
              'Amazon Captcha erkannt. Bitte öffne https://www.amazon.de im Browser auf dem gleichen Gerät/IP, melde dich ab und wieder an um das Captcha zu lösen. Danach den Adapter neu starten.',
            );
          }
          this.log.error(
            'Login to Amazon failed. Please check credentials and restart the adapter.',
          );
          delete this.cookieJar.store.idx['amazon.de'];
          delete this.cookieJar.store.idx['www.amazon.de'];
          this.setState('info.connection', false, true);

          return;
        }
        if (res.data.indexOf('Zurücksetzen des Passworts erforderlich') !== -1) {
          this.log.error('Zurücksetzen des Passworts erforderlich');
          return;
        }
        if (res.data.indexOf('transactionapproval') !== -1 || res.data.indexOf('Enter verification code') !== -1 || res.data.indexOf('Bestätigungscode eingeben') !== -1 || res.data.indexOf('verification-code-form') !== -1) {
          this.log.info('Amazon SMS verification required. A code was sent to your phone.');
          this.log.info('Please enter the code in the adapter settings (OTP field) and restart the adapter.');
          const form = this.extractHidden(res.data);
          delete form['undefined'];
          // extractHidden collects all forms - 'action' gets overwritten to 'resend' by later forms
          form['action'] = 'code';
          delete form['resendContactType'];
          delete form['timerMessage'];
          delete form['timerComplete'];
          // Extract actual form action from response page
          const cvfActionMatch = res.data.match(/<form[^>]*action=["']([^"']*)["']/i);
          let verifyUrl = 'https://www.amazon.de/ap/cvf/verify';
          if (cvfActionMatch) {
            verifyUrl = cvfActionMatch[1].replace(/&amp;/g, '&');
            if (verifyUrl.startsWith('/')) verifyUrl = 'https://www.amazon.de' + verifyUrl;
          }
          this.log.debug('CVF verify URL: ' + verifyUrl);
          const verification = {
            url: verifyUrl,
            form: form,
          };
          await this.setObjectNotExistsAsync('auth.amzVerification', {
            type: 'state',
            common: { name: 'Amazon Verification Data', write: false, read: true, type: 'string', role: 'json' },
            native: {},
          });
          await this.setStateAsync('auth.amzVerification', JSON.stringify(verification), true);
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          return;
        }
        if (res.data.indexOf('auth-select-device-form"') !== -1) {
          this.log.info('SMS code or call form found. If you do not receive a SMS then login to Amazon and trigger the SMS code');
          const form = this.extractHidden(res.data);
          delete form['undefined'];
          form['action'] = 'code';
          delete form['resendContactType'];
          delete form['timerMessage'];
          delete form['timerComplete'];
          const selectActionMatch = res.data.match(/<form[^>]*action=["']([^"']*)["']/i);
          let verifyUrl = 'https://www.amazon.de/ap/cvf/verify';
          if (selectActionMatch) {
            verifyUrl = selectActionMatch[1].replace(/&amp;/g, '&');
            if (verifyUrl.startsWith('/')) verifyUrl = 'https://www.amazon.de' + verifyUrl;
          }
          this.log.debug('Select device verify URL: ' + verifyUrl);
          const verification = {
            url: verifyUrl,
            form: form,
          };
          await this.setObjectNotExistsAsync('auth.amzVerification', {
            type: 'state',
            common: { name: 'Amazon Verification Data', write: false, read: true, type: 'string', role: 'json' },
            native: {},
          });
          await this.setStateAsync('auth.amzVerification', JSON.stringify(verification), true);
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          this.log.info('Please enter the SMS code in the adapter settings (OTP field) and restart the adapter.');
          return;
        }
        if (res.data.indexOf('isRedirectForWhatsapp') !== -1 || res.data.indexOf('cvf/approval') !== -1) {
          this.log.info('Amazon WhatsApp-Verifizierung erkannt. Versuche WhatsApp-Code anzufordern...');
          // Extract the form action URL for WhatsApp redirect
          const whatsappMatch = res.data.match(/action="([^"]*isRedirectForWhatsapp[^"]*)"/);
          if (whatsappMatch) {
            let whatsappUrl = whatsappMatch[1].replace(/&amp;/g, '&');
            if (whatsappUrl.startsWith('/')) {
              whatsappUrl = 'https://www.amazon.de' + whatsappUrl;
            }
            const whatsappRes = await this.requestClient({
              method: 'post',
              url: whatsappUrl,
              headers: {
                'content-type': 'application/x-www-form-urlencoded',
                accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
                origin: 'https://www.amazon.de',
                'accept-language': 'de-de',
                'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_8 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
              },
              data: '',
            }).catch((error) => {
              this.log.error('WhatsApp redirect failed: ' + error.message);
              return null;
            });
            if (whatsappRes && whatsappRes.data) {
              this.log.debug('WhatsApp response: ' + whatsappRes.data.substring(0, 2000));
              // After WhatsApp redirect we should get a verification code form
              const form = this.extractHidden(whatsappRes.data);
              delete form['undefined'];
              form['action'] = 'code';
              delete form['resendContactType'];
              delete form['timerMessage'];
              delete form['timerComplete'];
              // Extract actual form action URL from response
              const formActionMatch = whatsappRes.data.match(/<form[^>]*action=["']([^"']*)["']/i);
              let verifyUrl;
              if (formActionMatch) {
                verifyUrl = formActionMatch[1].replace(/&amp;/g, '&');
                if (verifyUrl.startsWith('/')) {
                  verifyUrl = 'https://www.amazon.de' + verifyUrl;
                }
              } else {
                // Fallback: use response URL or approval URL
                verifyUrl = whatsappRes.request?.res?.responseUrl || 'https://www.amazon.de/ap/cvf/verify';
              }
              this.log.info('Verify URL: ' + verifyUrl);
              const verification = { url: verifyUrl, form: form };
              await this.setObjectNotExistsAsync('auth.amzVerification', {
                type: 'state',
                common: { name: 'Amazon Verification Data', write: false, read: true, type: 'string', role: 'json' },
                native: {},
              });
              await this.setStateAsync('auth.amzVerification', JSON.stringify(verification), true);
              this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
              this.log.info('Amazon WhatsApp-Code wurde angefordert. Bitte den Code in den Adaptereinstellungen (OTP Feld) eingeben und den Adapter neu starten.');
            }
          } else {
            this.log.warn('Amazon WhatsApp-Verifizierung erkannt, aber kein Formular gefunden. Bitte manuell bei Amazon einloggen.');
          }
          return;
        }
        if (res.data.indexOf('captcha') !== -1 || res.data.indexOf('Löse das Rätsel, um dein Konto zu schützen') !== -1 || res.data.indexOf('cvf_captcha') !== -1) {
          this.log.warn('Amazon Captcha erkannt. Bitte öffne https://www.amazon.de im Browser auf dem gleichen Gerät/IP, melde dich ab und wieder an um das Captcha zu lösen. Danach den Adapter neu starten.');
          this.setState('info.connection', false, true);
          return;
        }
        this.log.error('Unknown Error: Login to Amazon failed, please login to Amazon and check your credentials');
        this.log.info(res.data);
        try {
          delete this.cookieJar.store.idx['amazon.de'];
          delete this.cookieJar.store.idx['www.amazon.de'];
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          this.log.info('Amazon Cookies gelöscht. Bitte Adapter neu starten.');
        } catch { /* ignore */ }
        this.setState('info.connection', false, true);
        return;
      })
      .catch(async (error) => {
        this.log.error('Failed to post with password to https://www.amazon.de/ap/signin');
        if (error.response) {
          this.setState('info.connection', false, true);
          this.log.error(JSON.stringify(error.response.data));
        }
        this.logAxiosError('Amazon/login', error);
        try {
          delete this.cookieJar.store.idx['amazon.de'];
          delete this.cookieJar.store.idx['www.amazon.de'];
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
          this.log.info('Amazon Cookies gelöscht nach Login-Fehler. Bitte Adapter neu starten.');
        } catch { /* ignore */ }
      });
  }
  // ------- DPD (SOAP) -------
  // Der eigentliche SOAP-Flow liegt in lib/dpdLogin.js (analog zu lib/dhlLogin.js).
  // Hier nur die Adapter-Klebeschicht: Session-Persistenz, State-Objekte,
  // Retry-Kaskade zwischen Fetch und Re-Login.
  /**
   * Löscht die DPD-Session aus dem laufenden Prozess UND aus dem persistierten
   * `auth.dpdSession`-State, damit weder ein aktuell laufender Fetch noch der
   * nächste Adapter-Start eine ungültige Session weiter benutzt.
   */
  async clearDPDSession() {
    delete this.sessions['dpd'];
    try {
      await this.setStateAsync('auth.dpdSession', '', true);
    } catch {
      /* noop */
    }
  }
  async loginDPD(silent) {
    const session = await dpdLoginSoap({
      requestClient: this.requestClient,
      username: this.config.dpdusername,
      password: this.config.dpdpassword,
      log: this.log,
    });
    if (!session) {
      await this.clearDPDSession();
      return;
    }
    this.sessions['dpd'] = session;
    !silent && this.log.info('Login to DPD successful (SOAP)');

    await this.setObjectNotExistsAsync('dpd', {
      type: 'device',
      common: { name: 'DPD Tracking' },
      native: {},
    });
    await this.setObjectNotExistsAsync('dpd.json', {
      type: 'state',
      common: { name: 'Json Sendungen', write: false, read: true, type: 'string', role: 'json' },
      native: {},
    });
    await this.setObjectNotExistsAsync('auth.dpdSession', {
      type: 'state',
      common: { name: 'DPD SOAP Session', write: false, read: true, type: 'string', role: 'json' },
      native: {},
    });
    this.setState('auth.dpdSession', JSON.stringify(session), true);
    this.setState('info.connection', true, true);
  }
  /**
   * Holt die aktuelle Sendungsliste. Bei ungültiger Session wird einmalig
   * ein Re-Login versucht.
   */
  async fetchDPDParcels(retry) {
    const session = this.sessions['dpd'];
    if (!session || !session.SessionToken) {
      this.log.debug('fetchDPDParcels: keine Session, überspringe');
      return null;
    }
    const result = await dpdFetchParcels({
      requestClient: this.requestClient,
      session,
      log: this.log,
    });
    if (!result) return null;
    if (result.status === 'ok') {
      if (result.sessionToken) {
        session.SessionToken = result.sessionToken;
        this.setState('auth.dpdSession', JSON.stringify(session), true);
      }
      return result.data;
    }
    if (result.status === 'invalid-session') {
      if (retry) {
        this.log.error(`[DPD/fetch] error after re-login: ${result.errorCode || 'unknown'}`);
        await this.clearDPDSession();
        return null;
      }
      this.log.info(`[DPD/fetch] session invalid (${result.errorCode || 'unknown'}), attempting re-login`);
      await this.loginDPD(true);
      if (this.sessions['dpd']) {
        return this.fetchDPDParcels(true);
      }
      return null;
    }
    // status === 'error' — vom Modul bereits geloggt
    return null;
  }
  async loginGLS(silent) {
    // Azure AD B2C Authorization-Code + PKCE flow — nachgebaut aus der GLS-App v6.3.0.
    // Werte aus res/raw/msal_config_prod.json der APK.
    const CLIENT_ID = 'b990fae6-1647-426b-b0a9-d51fcfed4fc8';
    const REDIRECT_URI = 'msauth://com.gls.glsappde.consumer/ulmVfvzqq5hHvhon9Kh4lu9Esy8%3D';
    const AUTHORITY = 'https://login.gls-group.net/login.gls-group.net';
    const POLICY = 'B2C_1A_PROD_DE_DF_SOCIAL_DEFAULT';
    const SCOPES = [
      'openid',
      'offline_access',
      'https://glsgroup.onmicrosoft.com/1635def9-6f7b-4720-be2d-7b49f8298756/GLSAPP-READ',
      'https://glsgroup.onmicrosoft.com/1635def9-6f7b-4720-be2d-7b49f8298756/GLSAPP-WRITE',
    ].join(' ');
    const UA = 'Mozilla/5.0 (Linux; Android 14; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Mobile Safari/537.36';

    const b64url = (buf) => buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
    const verifier = b64url(crypto.randomBytes(32));
    const challenge = b64url(crypto.createHash('sha256').update(verifier).digest());

    // Eigene Cookie-Jar/Client-Instanz für den B2C-Login, damit die Session-Cookies
    // (x-ms-cpim-*) nicht mit den anderen Providern kollidieren.
    const b2cJar = new tough.CookieJar();
    const b2cClient = axios.create({
      withCredentials: true,
      httpsAgent: new HttpsCookieAgent({ cookies: { jar: b2cJar }, rejectUnauthorized: false }),
      maxRedirects: 0,
      validateStatus: () => true,
      timeout: 20000,
    });

    // Schritt 1: /authorize aufrufen und csrf-Token + StateProperties(tx) aus dem HTML scrapen
    const authUrl =
      `${AUTHORITY}/${POLICY}/oauth2/v2.0/authorize?` +
      qs.stringify({
        client_id: CLIENT_ID,
        response_type: 'code',
        redirect_uri: REDIRECT_URI,
        scope: SCOPES,
        state: b64url(crypto.randomBytes(16)),
        nonce: b64url(crypto.randomBytes(16)),
        code_challenge: challenge,
        code_challenge_method: 'S256',
        response_mode: 'query',
      });
    let csrfToken;
    let tx;
    try {
      const res = await b2cClient.get(authUrl, {
        headers: { 'User-Agent': UA, Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' },
      });
      if (res.status !== 200) {
        this.log.error(`GLS B2C /authorize HTTP ${res.status}`);
        return;
      }
      const m = String(res.data).match(/var\s+SETTINGS\s*=\s*(\{[\s\S]*?\});/);
      if (!m) {
        this.log.error('GLS B2C: SETTINGS-Objekt in Login-Seite nicht gefunden.');
        return;
      }
      const settings = JSON.parse(m[1]);
      csrfToken = settings.csrf;
      tx = settings.transId;
      if (!csrfToken || !tx) {
        this.log.error('GLS B2C: csrf/transId fehlt.');
        return;
      }
    } catch (err) {
      this.log.error('GLS B2C /authorize Fehler: ' + err.message);
      return;
    }

    // Schritt 2: SelfAsserted-POST mit Username/Passwort
    try {
      const res = await b2cClient.post(
        `${AUTHORITY}/${POLICY}/SelfAsserted?tx=${encodeURIComponent(tx)}&p=${POLICY}`,
        qs.stringify({ request_type: 'RESPONSE', signInName: this.config.glsusername, password: this.config.glspassword }),
        {
          headers: {
            'User-Agent': UA,
            Accept: 'application/json, text/javascript, */*; q=0.01',
            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
            'X-CSRF-TOKEN': csrfToken,
            'X-Requested-With': 'XMLHttpRequest',
            Origin: 'https://login.gls-group.net',
          },
        },
      );
      const payload = typeof res.data === 'object' ? res.data : (() => { try { return JSON.parse(res.data); } catch { return null; } })();
      if (!payload || String(payload.status) !== '200') {
        this.log.error('GLS Login fehlgeschlagen: ' + JSON.stringify(payload || res.data));
        return;
      }
    } catch (err) {
      this.log.error('GLS B2C /SelfAsserted Fehler: ' + err.message);
      return;
    }

    // Schritt 3: confirmed-Redirect liefert den Authorization-Code
    let authCode;
    try {
      const res = await b2cClient.get(
        `${AUTHORITY}/${POLICY}/api/CombinedSigninAndSignup/confirmed?` +
          qs.stringify({ rememberMe: 'true', csrf_token: csrfToken, tx, p: POLICY }),
        { headers: { 'User-Agent': UA } },
      );
      const loc = res.headers && res.headers.location;
      if (res.status !== 302 || !loc) {
        this.log.error(`GLS B2C /confirmed HTTP ${res.status}, keine Redirect-Location.`);
        return;
      }
      const u = new URL(loc.replace(/^msauth:/i, 'https:'));
      authCode = u.searchParams.get('code');
      const err = u.searchParams.get('error');
      if (err) {
        this.log.error(`GLS B2C error=${err}: ${u.searchParams.get('error_description')}`);
        return;
      }
      if (!authCode) {
        this.log.error('GLS B2C: kein Authorization-Code im Redirect.');
        return;
      }
    } catch (err) {
      this.log.error('GLS B2C /confirmed Fehler: ' + err.message);
      return;
    }

    // Schritt 4: Code gegen Tokens tauschen
    try {
      const res = await b2cClient.post(
        `${AUTHORITY}/${POLICY}/oauth2/v2.0/token`,
        qs.stringify({
          client_id: CLIENT_ID,
          grant_type: 'authorization_code',
          scope: SCOPES,
          code: authCode,
          redirect_uri: REDIRECT_URI,
          code_verifier: verifier,
        }),
        { headers: { 'User-Agent': UA, 'Content-Type': 'application/x-www-form-urlencoded' } },
      );
      if (res.status !== 200 || !res.data || !res.data.access_token) {
        this.log.error('GLS Token-Redemption fehlgeschlagen: ' + JSON.stringify(res.data));
        return;
      }
      const session = {
        access_token: res.data.access_token,
        refresh_token: res.data.refresh_token,
        expires_at: Date.now() + Number(res.data.expires_in || 3600) * 1000,
      };
      this.sessions['gls'] = session;
      this.glstoken = session.access_token;
      !silent && this.log.info('Login to GLS successful');
      await this.setObjectNotExistsAsync('gls', {
        type: 'device',
        common: { name: 'GLS Tracking' },
        native: {},
      });
      await this.setObjectNotExistsAsync('gls.json', {
        type: 'state',
        common: { name: 'Json Sendungen', write: false, read: true, type: 'string', role: 'json' },
        native: {},
      });
      await this.setObjectNotExistsAsync('auth.glsSession', {
        type: 'state',
        common: { name: 'GLS OAuth Session', write: false, read: true, type: 'string', role: 'json' },
        native: {},
      });
      this.setState('auth.glsSession', JSON.stringify(session), true);
      this.setState('info.connection', true, true);
    } catch (err) {
      this.log.error('GLS B2C /token Fehler: ' + err.message);
    }
  }
  async refreshGLSToken(silent) {
    // Silent Refresh via refresh_token-Grant; bei Fehlschlag Full-Login.
    const session = this.sessions['gls'];
    if (!session || !session.refresh_token) {
      return this.loginGLS(silent);
    }
    const CLIENT_ID = 'b990fae6-1647-426b-b0a9-d51fcfed4fc8';
    const AUTHORITY = 'https://login.gls-group.net/login.gls-group.net';
    const POLICY = 'B2C_1A_PROD_DE_DF_SOCIAL_DEFAULT';
    const SCOPES = [
      'openid',
      'offline_access',
      'https://glsgroup.onmicrosoft.com/1635def9-6f7b-4720-be2d-7b49f8298756/GLSAPP-READ',
      'https://glsgroup.onmicrosoft.com/1635def9-6f7b-4720-be2d-7b49f8298756/GLSAPP-WRITE',
    ].join(' ');
    try {
      const res = await this.requestClient({
        method: 'post',
        url: `${AUTHORITY}/${POLICY}/oauth2/v2.0/token`,
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        data: qs.stringify({
          client_id: CLIENT_ID,
          grant_type: 'refresh_token',
          scope: SCOPES,
          refresh_token: session.refresh_token,
        }),
        validateStatus: () => true,
        timeout: 20000,
      });
      if (res.status !== 200 || !res.data || !res.data.access_token) {
        this.log.info('GLS refresh_token abgelaufen, führe Full-Login aus.');
        return this.loginGLS(silent);
      }
      const newSession = {
        access_token: res.data.access_token,
        refresh_token: res.data.refresh_token || session.refresh_token,
        expires_at: Date.now() + Number(res.data.expires_in || 3600) * 1000,
      };
      this.sessions['gls'] = newSession;
      this.glstoken = newSession.access_token;
      this.setState('auth.glsSession', JSON.stringify(newSession), true);
      this.setState('info.connection', true, true);
      !silent && this.log.info('GLS token refreshed');
    } catch (err) {
      this.log.error('GLS refresh Fehler: ' + err.message);
      return this.loginGLS(silent);
    }
  }
  async loginHermes() {
    await this.requestClient({
      method: 'post',
      url: 'https://mobile-app-api.a0930.prd.hc.de/api/v12/users/login',
      headers: {
        accept: 'application/json',
        'api-key': 'acefe97f-89fc-4f4e-9543-fc6b90f68928',
        'content-type': 'application/json; charset=utf-8',
        'user-agent': 'Hermes - ios - 12.1.1 (2689)',
        'accept-language': 'de-de',
      },
      data: { username: this.config.hermesusername, password: this.config.hermespassword },
    })
      .then(async (res) => {
        this.log.debug(JSON.stringify(res.data));
        if (res.data.accessToken) {
          this.hermesAuthToken = res.data.accessToken;
          this.sessions['hermes'] = res.data;
          this.log.info('Login to Hermes successful');
          await this.setObjectNotExistsAsync('hermes', {
            type: 'device',
            common: {
              name: 'Hermes Tracking',
            },
            native: {},
          });
          await this.setObjectNotExistsAsync('hermes.json', {
            type: 'state',
            common: {
              name: 'Json Sendungen',
              write: false,
              read: true,
              type: 'string',
              role: 'json',
            },
            native: {},
          });
          this.setState('info.connection', true, true);
        } else {
          this.log.error('Login to Hermes failed');
          this.log.error(JSON.stringify(res.data));
        }

        return;
      })
      .catch((error) => {
        this.logAxiosError('Hermes/login', error);
        if (error.response) {
          this.log.error(JSON.stringify(error.response.data));
        }
      });
  }
  async loginUPS(silent) {
    await this.requestClient({
      method: 'post',
      url: 'https://onlinetools.ups.com/rest/Login',
      headers: {
        Connection: 'keep-alive',
        Accept: 'application/json',
        'Content-Type': 'application/json',
        Host: 'onlinetools.ups.com',
      },
      data: JSON.stringify({
        UPSSecurity: {
          UsernameToken: {},
          ServiceAccessToken: {
            AccessLicenseNumber: '3DE112BAD1F163E0',
          },
        },
        LoginSubmitUserIdRequest: {
          UserId: this.config.upsusername,
          Password: this.config.upspassword,
          Locale: 'de_DE',
          ClientID: 'native',
          IsMobile: 'true',
        },
      }),
    })
      .then(async (res) => {
        this.log.debug(JSON.stringify(res.data));
        if (
          res.data.LoginSubmitUserIdResponse &&
          res.data.LoginSubmitUserIdResponse.LoginResponse &&
          res.data.LoginSubmitUserIdResponse.LoginResponse.AuthenticationToken
        ) {
          this.upsAuthToken = res.data.LoginSubmitUserIdResponse.LoginResponse.AuthenticationToken;

          this.sessions['ups'] = res.data;
          !silent && this.log.info('Login to UPS successful');
          await this.setObjectNotExistsAsync('ups', {
            type: 'device',
            common: {
              name: 'UPS Tracking',
            },
            native: {},
          });
          await this.setObjectNotExistsAsync('ups.json', {
            type: 'state',
            common: {
              name: 'Json Sendungen',
              write: false,
              read: true,
              type: 'string',
              role: 'json',
            },
            native: {},
          });
          this.setState('info.connection', true, true);
          this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
        } else {
          this.log.warn('Login to UPS failed');
          this.log.info(JSON.stringify(res.data));
          if (JSON.stringify(res.data).includes('Legal Agreement Required')) {
            this.log.warn('Please login into UPS and accept the Legal Agreement');
          }
        }

        return;
      })
      .catch((error) => {
        this.logAxiosError('UPS/login', error);
        if (error.response) {
          this.log.error(JSON.stringify(error.response.data));
        }
      });
    if (!this.upsAuthToken) {
      return;
    }
    await this.requestClient({
      method: 'post',
      url: 'https://onlinetools.ups.com/rest/MCEnrollment',
      headers: {
        Connection: 'keep-alive',
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      data: JSON.stringify({
        UPSSecurity: {
          UsernameToken: {
            AuthenticationToken: this.upsAuthToken,
          },
          ServiceAccessToken: {
            AccessLicenseNumber: '3DE112BAD1F163E0',
          },
        },
        GetEnrollmentsRequest: {
          Request: {
            RequestOption: ['00'],
            TransactionReference: {},
          },
          Locale: {
            Language: 'de',
            Country: 'DE',
          },
        },
      }),
    })
      .then(async (res) => {
        this.log.debug(JSON.stringify(res.data));
        if (
          res.data.GetEnrollmentsResponse &&
          res.data.GetEnrollmentsResponse.MYCEnrollmentSummaries &&
          res.data.GetEnrollmentsResponse.MYCEnrollmentSummaries.MYCEnrollmentSummary &&
          res.data.GetEnrollmentsResponse.MYCEnrollmentSummaries.MYCEnrollmentSummary.AddressToken
        ) {
          this.upsAddressToken = res.data.GetEnrollmentsResponse.MYCEnrollmentSummaries.MYCEnrollmentSummary.AddressToken;
        } else {
          this.log.warn('No UPS address found. Please activate UPS My Choice in the UPS App');
          this.log.info(JSON.stringify(res.data));
        }
      })
      .catch(async (error) => {
        this.logAxiosError('UPS/login', error);
      });
  }
  async login17TApi() {
    await this.setObjectNotExistsAsync('17t', {
      type: 'device',
      common: {
        name: '17Track API Tracking',
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('17t.trackinginfo', {
      type: 'channel',
      common: {
        name: '17Track Tracking Info',
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('17t.trackinginfo.json', {
      type: 'state',
      common: {
        name: 'Json Sendungen',
        write: false,
        read: true,
        type: 'string',
        role: 'json',
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('17t.register', {
      type: 'state',
      common: {
        name: 'Register Tracking ID',
        write: true,
        read: true,
        type: 'mixed',
        role: 'state',
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('17t.trackList', {
      type: 'state',
      common: {
        role: 'state',
        name: 'Registered tracking ids',
        type: 'object',
        read: true,
        write: false,
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('17t.deleteTrack', {
      type: 'state',
      common: {
        role: 'state',
        name: 'Unregister a tracking id',
        type: 'mixed',
        read: true,
        write: true,
      },
      native: {},
    });
  }
  async login17T(silent) {
    await this.requestClient({
      method: 'post',
      url: 'https://user.17track.net/userapi/call',
      headers: {
        accept: '*/*',
        'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
        'x-requested-with': 'XMLHttpRequest',
        'accept-language': 'de,en;q=0.9',
      },
      data:
        '{"version":"1.0","method":"Signin","param":{"Email":"' +
        this.config.t17username +
        '","Password":"' +
        this.config.t17password +
        '","CaptchaCode":""},"sourcetype":0,"timeZoneOffset":-60}',
    })
      .then(async (res) => {
        this.log.debug(JSON.stringify(res.data));
        if (res.data && res.data.Message) {
          this.log.error('Login to 17TUser failed. Login via Google is not working');
          this.log.error('T17User: ' + res.data.Message);
          return;
        }
        !silent && this.log.info('Login to T17 User successful');
        this.sessions['17tuser'] = true;
        await this.setObjectNotExistsAsync('17tuser', {
          type: 'device',
          common: {
            name: '17Track User Tracking',
          },
          native: {},
        });
        await this.setObjectNotExistsAsync('17tuser.trackinginfo.json', {
          type: 'state',
          common: {
            name: 'Json Sendungen',
            write: false,
            read: true,
            type: 'string',
            role: 'json',
          },
          native: {},
        });
        await this.setObjectNotExistsAsync('17tuser.register', {
          type: 'state',
          common: {
            name: 'Register Tracking ID',
            write: true,
            read: true,
            type: 'mixed',
            role: 'state',
          },
          native: {},
        });
        this.setState('info.connection', true, true);
        this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
        return;
      })
      .catch(async (error) => {
        this.logAxiosError('17Track/login', error);
      });
  }
  async updateProvider() {
    this.log.debug('updateProvider started. Sessions: ' + JSON.stringify(Object.keys(this.sessions)));
    let data17Track = {};
    let dataDhl = [];
    this.mergedJson = [];
    this.mergedJsonObject = {};
    this.inDelivery = [];
    this.notDelivered = [];
    if (this.sessions['17track']) {
      try {
        const trackList = await this.getStateAsync('17t.trackList');
        if (trackList && trackList.val) {
          if (!trackList.val.map) {
            trackList.val = JSON.parse(trackList.val);
          }
          data17Track = trackList.val.map((track) => {
            return { number: track };
          });
        }
      } catch (error) {
        this.logAxiosError('17Track/user', error);
      }
    }
    if (this.sessions['dhl']) {
      // Remove stale Akamai bot-detection cookies that cause ECONNRESET/ETIMEDOUT
      for (const domain of ['dhl.de', 'www.dhl.de']) {
        if (this.cookieJar.store.idx[domain]) {
          for (const path of Object.keys(this.cookieJar.store.idx[domain])) {
            for (const name of Object.keys(this.cookieJar.store.idx[domain][path])) {
              if (name === '_abck' || name === 'ak_bmsc' || name === 'bm_sz') {
                delete this.cookieJar.store.idx[domain][path][name];
              }
            }
          }
        }
      }
      dataDhl = await this.requestClient({
        method: 'get',
        url: 'https://www.dhl.de/int-verfolgen/data/search?noRedirect=true&language=de&cid=app',
        headers: {
          accept: 'application/json',
          'content-type': 'application/json',
          'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_8 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
          'accept-language': 'de-de',
        },
        timeout: 15000,
      })

        .then(async (res) => {
          this.log.debug(JSON.stringify(res.data));
          if (res.data && res.data.sendungen) {
            return res.data.sendungen
              .filter((sendung) => sendung.sendungsinfo.sendungsliste !== 'ARCHIVIERT')
              .map((sendung) => sendung.id);
          }
          return [];
        })
        .catch((error) => {
          if (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT') {
            this.log.info('DHL is not available. Maybe the DHL service down or overloaded at the moment');
          } else {
            this.log.error('Failed to get https://www.dhl.de/int-verfolgen/data/search?noRedirect=true&language=de&cid=app');
            this.logAxiosError('DHL/fetch', error);
            error.response && this.log.error(JSON.stringify(error.response.data));
          }
          return [];
        });
    }
    if (this.sessions['amz']) {
      await this.getAmazonPackages();
    }
    const statusArrays = {
      dhl: [
        {
          path: 'dhl',
          url: 'https://www.dhl.de/int-verfolgen/data/search?piececode=' + dataDhl + '&noRedirect=true&language=de&cid=app',
          header: {
            accept: 'application/json',
            'content-type': 'application/json',
            'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_8 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
            'accept-language': 'de-de',
          },
        },
        {
          path: 'dhl.briefe',
          url: 'https://www.dhl.de/int-aviseanzeigen/advices?width=414',
          header: {
            accept: 'application/json',
            'content-type': 'application/json',
            'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_8 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
            'accept-language': 'de-de',
          },
        },
      ],
      '17track': [
        {
          method: 'post',
          path: '17t.trackinginfo',
          url: 'https://api.17track.net/track/v1/gettrackinfo',
          header: {
            '17token': this.config['17trackKey'],
            'Content-Type': 'application/json',
          },
          data: JSON.stringify(data17Track),
        },
      ],
      '17tuser': [
        {
          method: 'post',
          path: '17tuser.trackinginfo',
          url: 'https://buyer.17track.net/orderapi/call',
          data: '{"version":"1.0","timeZoneOffset":-60,"method":"GetTrackInfoList","param":{"ob":"1","Page":1,"IsArchived":false}}',
          header: { 'content-type': 'application/x-www-form-urlencoded' },
        },
      ],
      amz: [],
      // DPD läuft über SOAP (getSessionFullState), nicht über generisches HTTP-GET.
      // Der Marker `custom: 'dpd'` sagt dem Loop weiter unten: nicht requestClient,
      // sondern fetchDPDParcels() aufrufen. Rest der Pipeline (cleanupProvider,
      // mergeProviderJson, json2iob.parse, setState 'dpd.json') bleibt identisch.
      dpd: [
        { path: 'dpd', custom: 'dpd' },
      ],
      gls: [
        {
          path: 'gls',
          url: 'https://gls-pakete-de-backend-app.ooh.glsnxt.com/api/v1/trackings',
          header: {
            accept: 'application/json',
            'user-agent': 'Mozilla/5.0 (Linux; Android 14; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Mobile Safari/537.36',
            'accept-language': 'de-de',
            authorization: 'Bearer ' + this.glstoken,
          },
        },
      ],
      hermes: [
        {
          path: 'hermes',
          url: 'https://mobile-app-api.a0930.prd.hc.de/api/v12/shipments',
          header: {
            accept: 'application/json',
            'api-key': 'acefe97f-89fc-4f4e-9543-fc6b90f68928',
            'user-agent': 'Hermes - ios - 12.1.1 (2689)',
            'accept-language': 'de-de',
            authorization: 'Bearer ' + this.hermesAuthToken,
          },
        },
      ],
      ups: [
        {
          path: 'ups',
          method: 'post',
          url: 'https://onlinetools.ups.com/mychoice/v1/shipments/details/AddressToken?loc=de_DE',
          header: {
            Connection: 'keep-alive',
            Accept: 'application/json',
            AccessLicenseNumber: '3DE112BAD1F163E0',
            AuthenticationToken: this.upsAuthToken,
            addresstoken: this.upsAddressToken,
            transID: crypto.randomUUID().substring(0, 25),
            transactionSrc: 'MOBILE',
            'Content-Type': 'application/json',
          },
          data: JSON.stringify({
            parcelCount: '10',
            disableFeature: '',
          }),
        },
      ],
    };

    for (const id of Object.keys(this.sessions)) {
      // Provider ohne generischen statusArrays-Eintrag (z.B. DPD läuft
      // über den eigenen SOAP-Fetch weiter oben) hier überspringen.
      if (!statusArrays[id]) continue;
      for (const element of statusArrays[id]) {
        // Custom-Fetch: statt requestClient wird der Provider-eigene
        // Fetch aufgerufen, das Ergebnis läuft aber durch dieselbe .then()-Pipeline
        // (cleanupProvider → mergeProviderJson → json2iob.parse → setState).
        const requestFn = element.custom === 'dpd'
          ? async () => {
            const data = await this.fetchDPDParcels();
            return { data: data || null };
          }
          : () => this.requestClient({
            method: element.method ? element.method : 'get',
            url: element.url,
            headers: element.header,
            data: element.data,
            timeout: element.url && element.url.includes('dhl.de') ? 15000 : undefined,
          });
        if (!element.custom) {
          this.log.debug(element.url);
        }
        if (this.ignoredPath.includes(element.path)) {
          this.log.debug('Ignore: ' + element.path);
          continue;
        }
        await requestFn()
          .then(async (res) => {
            this.log.debug(JSON.stringify(res.data));
            if (!res.data) {
              return;
            }
            let data = res.data;
            if (id === '17track') {
              data = res.data.data;
            }
            if (id === '17tuser') {
              data = res.data.Json;
            }
            if (id === 'gls') {
              // Neues Backend (glsnxt.com/api/v1/trackings) liefert { trackings: [...], pageInfo: {...} }
              // Jedes Tracking: { id, trackingReference, parcelNumber, name, parcelIcon, deliveryDirection,
              //                    deliveredAt, latestStatusText, unlocked, hasDeliveryAttemptFailed, addedAt, ... }
              const parcels = Array.isArray(res.data && res.data.trackings) ? res.data.trackings : [];
              data = { sendungen: parcels };
            }
            if (id === 'ups') {
              for (const parcel of res.data.response.shipments) {
                parcel.id = parcel.trackingNumber;
              }
              data = { sendungen: res.data.response.shipments };
            }
            if (id === 'hermes') {
              try {
                if (res.data) {
                  if (typeof res.data === 'string') {
                    res.data = JSON.parse(res.data);
                  }
                  for (const parcel of res.data) {
                    parcel.id = parcel.shipmentId || parcel.externalId;
                  }
                  data = { sendungen: res.data };
                }
              } catch (error) {
                this.log.warn('Hermes response incomplete cannot parse result');
                this.log.debug(res.data);
                this.log.debug(error);
                data = { sendungen: [] };
              }
            }
            const forceIndex = true;
            const preferedArrayName = null;
            // filter archive message
            if (id === 'dhl' && data.sendungen) {
              const trackingList = [];
              data.sendungen = data.sendungen.filter((sendung) => {
                trackingList.push(sendung.id);
                return sendung.sendungsinfo.sendungsliste !== 'ARCHIVIERT';
              });
            }
            //activate briefe token
            if (element.path === 'dhl.briefe' && res.data.grantToken) {
              await this.activateToken(res.data.grantToken, res.data.accessTokenUrl);
              await this.sleep(1000);
            }
            if (data) {
              await this.cleanupProvider(id, data);
              this.mergeProviderJson(id, data);
              this.json2iob.parse(element.path, data, {
                forceIndex: forceIndex,
                preferedArrayName: preferedArrayName,
                dontSaveCreatedObjects: true,
              });
              data && this.setState(element.path + '.json', JSON.stringify(data), true);
            }
          })
          .catch((error) => {
            if (error.response) {
              if (error.response.status === 401 && id !== '17track') {
                if (element.path === 'dhl.briefe') {
                  this.log.debug(error);
                  return;
                }

                error.response && this.log.debug(JSON.stringify(error.response.data));

                this.log.info(element.path + ' receive 401 error. Refresh Token in 60 seconds');
                if (!this.refreshTokenTimeout) {
                  this.refreshTokenTimeout = setTimeout(() => {
                    this.refreshTokenTimeout = null;
                    this.refreshToken();
                  }, 1000 * 60);
                }
                return;
              }
              if (element.path === 'dhl.briefe') {
                this.log.info('Briefankündigung is not working. Stopped until restart');
                this.ignoredPath.push(element.path);
              }
            }
            if (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT') {
              this.log.info(id + ' is not available. Maybe the service down or overloaded at the moment');
            } else {
              this.log.error(element.url);
              this.logAxiosError('Update/fetch', error);
              error.response && this.log.error(JSON.stringify(error.response.data));
            }
          });
      }
    }
    this.log.debug('Write states');
    this.setState('allProviderJson', JSON.stringify(this.mergedJson), true);
    this.setState('allProviderObjects', JSON.stringify(this.mergedJsonObject), true);
    this.setState('inDelivery', JSON.stringify(this.inDelivery), true);
    this.setState('notDelivered', JSON.stringify(this.notDelivered), true);
    this.setState('inDeliveryCount', this.inDelivery.length, true);
    this.setState('notDeliveredCount', this.notDelivered.length, true);
    const inDeliveryJson = {};
    for (const sendung of this.inDelivery) {
      inDeliveryJson[sendung.source] = inDeliveryJson[sendung.source] ? inDeliveryJson[sendung.source] + 1 : 1;
    }
    this.setState('inDeliveryCountJson', JSON.stringify(inDeliveryJson), true);
  }
  async cleanupProvider(id, data) {
    //eslint-disable-next-line
    if (id === 'dhl' && data.hasOwnProperty('grantToken')) {
      await this.delObjectAsync('dhl.briefe', { recursive: true });
      await this.setObjectNotExistsAsync('dhl.briefe.json', {
        type: 'state',
        common: {
          name: 'Json Briefe',
          write: false,
          read: true,
          type: 'string',
          role: 'json',
        },
        native: {},
      });
    }
    if ((id === 'dhl' || id === 'dpd' || id === 'amz' || id === 'gls' || id === 'ups' || id === 'hermes') && data && data.sendungen) {
      const states = await this.getStatesAsync(id + '.sendungen*.id');
      const sendungsArray = data.sendungen.map((sendung) => {
        return sendung.id;
      });
      for (const sendungsIdKey in states) {
        const index = Object.keys(states).indexOf(sendungsIdKey);
        if (states[sendungsIdKey]) {
          const sendungsId = states[sendungsIdKey].val;
          if (sendungsArray[index] !== sendungsId) {
            const idArray = sendungsIdKey.split('.');
            idArray.pop();
            this.log.debug('deleting ' + sendungsIdKey);
            await this.delObjectAsync(idArray.join('.'), { recursive: true });
          }
        }
      }
    }
  }
  async mergeProviderJson(id, data) {
    this.log.debug(id + ' merge provider json');
    if (id === 'dhl' && data.sendungen) {
      const sendungsArray = data.sendungen.map((sendung) => {
        let status = '';

        if (sendung.sendungsdetails && sendung.sendungsdetails.sendungsverlauf && (sendung.sendungsdetails.sendungsverlauf.kurzStatus || sendung.sendungsdetails.sendungsverlauf.status)) {
          status = sendung.sendungsdetails.sendungsverlauf.kurzStatus || sendung.sendungsdetails.sendungsverlauf.status;
        }
        if (sendung.sendungsdetails && sendung.sendungsdetails.liveTracking) {
          let stopps = 0;
          if (sendung.sendungsdetails.liveTracking && sendung.sendungsdetails.liveTracking.countdown) {
            stopps = sendung.sendungsdetails.liveTracking.countdown;
          }
          status = status + ' ' + stopps + ' Stopps';
        }
        if (sendung.sendungsdetails && sendung.sendungsdetails.zustellung && sendung.sendungsdetails.zustellung.zustellzeitfensterBis) {
          const bisDate = new Date(sendung.sendungsdetails.zustellung.zustellzeitfensterBis).toLocaleTimeString('de-DE');
          const vonDate = new Date(sendung.sendungsdetails.zustellung.zustellzeitfensterVon).toLocaleTimeString('de-DE');
          status = status + ' ' + vonDate + '-' + bisDate;
        }
        const name = sendung.sendungsinfo.sendungsname || 'Unbekannt';

        const sendungsObject = { id: sendung.id, name: name, status: status, source: 'DHL' };

        sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
        if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
          sendungsObject.inDelivery = true;
          this.inDelivery.push(sendungsObject);
        }
        if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
          this.notDelivered.push(sendungsObject);
        }
        sendungsObject.direction = sendung.sendungsinfo.sendungsrichtung;
        this.mergedJsonObject[sendung.id] = sendungsObject;

        return sendungsObject;
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }
    if (id === 'gls' && data.sendungen) {
      const sendungsArray = data.sendungen.map((sendung) => {
        // Neues Schema (glsnxt): { id (UUID), trackingReference, parcelNumber, name, latestStatusText,
        //                          deliveryDirection: "INCOMING"|"OUTGOING", deliveredAt, hasDeliveryAttemptFailed, ... }
        const sendungsObject = {
          id: sendung.id,
          tracking: sendung.trackingReference || sendung.parcelNumber,
          name: sendung.name || sendung.parcelNumber || sendung.trackingReference,
          status: sendung.latestStatusText || '',
          source: 'GLS',
          direction: sendung.deliveryDirection,
        };

        sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
        if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
          sendungsObject.inDelivery = true;
          this.inDelivery.push(sendungsObject);
        }
        if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
          this.notDelivered.push(sendungsObject);
        }
        this.mergedJsonObject[sendung.id] = sendungsObject;
        return sendungsObject;
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }
    if (id === 'ups' && data.sendungen) {
      const sendungsArray = data.sendungen.map((sendung) => {
        const sendungsObject = {
          id: sendung.id,
          name: sendung.shipFromName,
          status: sendung.locStatus || sendung.status,
          source: 'UPS',
        };

        sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
        if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
          sendungsObject.inDelivery = true;
          this.inDelivery.push(sendungsObject);
        }
        if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
          this.notDelivered.push(sendungsObject);
        }
        this.mergedJsonObject[sendung.id] = sendungsObject;

        return sendungsObject;
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }
    if (id === 'hermes' && data.sendungen) {
      try {
        const sendungsArray = data.sendungen.map((sendung) => {
          let name = sendung.description;
          if (sendung.sender && sendung.sender.lastname) {
            name = name + ' ' + sendung.sender.lastname;
          }
          const sendungsObject = {
            id: sendung.id,
            tracking: sendung.order,
            name: name,
            status: sendung.status.text.longText || '',
            source: 'Hermes',
          };

          sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
          this.mergedJsonObject[sendung.id] = sendungsObject;
          if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
            sendungsObject.inDelivery = true;
            this.inDelivery.push(sendungsObject);
          }
          if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
            this.notDelivered.push(sendungsObject);
          }

          return sendungsObject;
        });
        this.mergedJson = this.mergedJson.concat(sendungsArray);
      } catch (error) {
        this.log.info('Hermes response incomplete cannot parse result');
        this.log.info(error);
      }
    }

    if (id === 'dpd' && data && data.sendungen) {
      const sendungsArray = data.sendungen.map((sendung) => {
        const sendungsObject = {
          id: sendung.id,
          name: sendung.name,
          status: sendung.status || '',
          source: 'DPD',
          direction: sendung.direction, // send / receive / return
          eta: sendung.eta || '',
        };

        // Wenn schon vom Server "Delivered=true" gemeldet, direkt DELIVERED
        if (sendung.delivered) {
          sendungsObject.delivery_status = this.delivery_status.DELIVERED;
        } else {
          sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
        }
        if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
          sendungsObject.inDelivery = true;
          this.inDelivery.push(sendungsObject);
        }
        if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
          this.notDelivered.push(sendungsObject);
        }
        this.mergedJsonObject[sendung.id] = sendungsObject;

        return sendungsObject;
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }
    if (id === 'amz' && data && data.sendungen) {
      const sendungsArray = data.sendungen.map((sendung) => {
        const sendungsObject = {
          id: sendung.id,
          name: sendung.name,
          status: sendung.status,
          source: 'AMZ',
          tracking: sendung.detailedState.signInRedirectUrl,
        };

        sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
        if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
          sendungsObject.inDelivery = true;
          this.inDelivery.push(sendungsObject);
        }
        if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
          this.notDelivered.push(sendungsObject);
        }
        this.mergedJsonObject[sendung.id] = sendungsObject;

        return sendungsObject;
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }
    if (id === '17track' && data.accepted) {
      const sendungsArray = data.accepted.map((sendung) => {
        const sendungsObject = {
          id: sendung.number,
          name: sendung.number,
          status: sendung.track.z0 ? sendung.track.z0.z : '',
          source: '17track',
        };
        if (!this.mergedJsonObject[sendung.id]) {
          sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
          if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
            sendungsObject.inDelivery = true;
            this.inDelivery.push(sendungsObject);
          }
          if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
            this.notDelivered.push(sendungsObject);
          }
          this.mergedJsonObject[sendung.id] = sendungsObject;
        }
        return sendungsObject;
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }
    if (id === '17tuser' && data) {
      const sendungsArray = data.map((sendung) => {
        try {
          if (sendung.FLastEvent) {
            sendung.FLastEvent = JSON.parse(sendung.FLastEvent);
          }
          const sendungsObject = {
            id: sendung.FTrackNo,
            name: sendung.FTrackInfoId,
            status: sendung.FLastEvent ? sendung.FLastEvent.z : '',
            source: '17tuser',
          };
          if (!this.mergedJsonObject[sendung.id]) {
            sendungsObject.delivery_status = this.deliveryStatusCheck(sendung, id, sendungsObject);
            if (sendungsObject.delivery_status === this.delivery_status.OUT_FOR_DELIVERY) {
              sendungsObject.inDelivery = true;
              this.inDelivery.push(sendungsObject);
            }
            if (sendungsObject.delivery_status !== this.delivery_status.DELIVERED) {
              this.notDelivered.push(sendungsObject);
            }
            this.mergedJsonObject[sendung.id] = sendungsObject;
          }
          return sendungsObject;
        } catch (error) {
          this.logAxiosError('17Track/parse', error);
        }
      });
      this.mergedJson = this.mergedJson.concat(sendungsArray);
    }

    if (this.config.sendToActive) {
      const sendungen = this.mergedJsonObject;
      const ids = Object.keys(sendungen);
      for (const id of ids) {
        if (
          this.alreadySentMessages[id + sendungen[id].source] === sendungen[id].status ||
          sendungen[id].status === '' ||
          sendungen[id].status === 'undefined' ||
          sendungen[id].status === 'null'
        ) {
          continue;
        }

        this.alreadySentMessages[id + sendungen[id].source] = sendungen[id].status;
        if (this.config.noFirstStartSend && this.firstStart) {
          continue;
        }
        const sendInstances = this.config.sendToInstance.replace(/ /g, '').split(',');
        const sendUser = this.config.sendToUser.replace(/ /g, '').split(',');
        for (const sendInstance of sendInstances) {
          let text = '📦 ' + sendungen[id].source + ' ' + sendungen[id].name + '\n' + sendungen[id].status;
          if (sendUser.length > 0) {
            for (const user of sendUser) {
              if (sendInstance.includes('pushover')) {
                await this.sendToAsync(sendInstance, {
                  device: user,
                  message: text,
                  title: 'Paketstatus',
                });
              } else if (sendInstance.includes('signal-cmb')) {
                await this.sendToAsync(sendInstance, 'send', {
                  text: text,
                  phone: user,
                });
              } else if (sendInstance.includes('telegram')) {
                let url = '';
                const trackingId = sendungen[id].tracking || id;
                if (sendungen[id].source === 'DHL') {
                  url = 'https://www.dhl.de/de/privatkunden/dhl-sendungsverfolgung.html?piececode=' + trackingId;
                }
                if (sendungen[id].source === 'AMZ') {
                  url = 'https://www.amazon.de' + trackingId;
                }
                if (sendungen[id].source === 'GLS') {
                  url = 'https://gls-group.eu/DE/de/paketverfolgung?match=' + trackingId;
                }
                if (sendungen[id].source === 'DPD') {
                  url = 'https://tracking.dpd.de/parcelstatus?query=' + trackingId;
                }
                if (sendungen[id].source === 'UPS') {
                  url = 'https://www.ups.com/track?loc=de_DE&tracknum=' + trackingId;
                }
                if (sendungen[id].source === 'Hermes') {
                  url = 'https://www.myhermes.de/empfangen/sendungsverfolgung/sendungsinformation/?trackingnumber=' + trackingId;
                }
                let name = sendungen[id].name;
                if (name != null && name.replace) {
                  name = name.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
                }
                let status = sendungen[id].status;
                if (status != null && status.replace) {
                  status = status.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
                }
                text = '📦 <a href="' + url + '">' + sendungen[id].source + '</a> ' + name + '\n' + status;
                await this.sendToAsync(sendInstance, { user: user, text: text, disable_web_page_preview: true, parse_mode: 'HTML' });
              } else {
                await this.sendToAsync(sendInstance, { user: user, text: text });
              }
            }
          } else {
            if (sendInstance.includes('pushover')) {
              await this.sendToAsync(sendInstance, { message: text, title: 'Paketstatus' });
            } else if (sendInstance.includes('signal-cmb')) {
              await this.sendToAsync(sendInstance, 'send', {
                text: text,
              });
            } else {
              await this.sendToAsync(sendInstance, text);
            }
          }
        }
      }
    }
  }
  inDeliveryCheck(sendungsObject) {
    if (!sendungsObject.status) {
      return false;
    }
    if (
      sendungsObject.status.toLocaleLowerCase().includes('in zustellung') ||
      sendungsObject.status.toLocaleLowerCase().includes('zustellung heute') ||
      //sendungsObject.status.toLocaleLowerCase().includes("heute zugestell") ||
      sendungsObject.status.toLocaleLowerCase().includes('wird zugestellt') ||
      sendungsObject.status.toLocaleLowerCase().includes('zustellfahrzeug')
    ) {
      if (this.deliveredCheck(sendungsObject)) {
        return false;
      }
      return true;
    }
    return false;
  }
  deliveredCheck(sendungsObject) {
    if (!sendungsObject.status) {
      return false;
    }
    if (
      sendungsObject.status.toLocaleLowerCase().includes('geliefert heute') ||
      sendungsObject.status.toLocaleLowerCase().includes('geliefert. heute zugestellt') ||
      sendungsObject.status.toLocaleLowerCase().includes('unterschrieben von') ||
      sendungsObject.status.toLocaleLowerCase().includes('hausbewohner übergeben') ||
      sendungsObject.status.toLocaleLowerCase().includes('zustellung erfolgreich') ||
      sendungsObject.status.toLocaleLowerCase().includes('paket zugestellt')
    ) {
      return true;
    }
    return false;
  }
  deliveryStatusCheck(sendung, id, sendungsObject) {
    try {
      if (sendung) {
        if (
          id === 'dhl' &&
          sendung.sendungsdetails &&
          sendung.sendungsdetails.sendungsverlauf &&
          sendung.sendungsdetails.sendungsverlauf.fortschritt
        ) {
          const dhl_status = {
            0: this.delivery_status.REGISTERED,
            1: this.delivery_status.REGISTERED,
            2: this.delivery_status.IN_PREPARATION,
            3: this.delivery_status.IN_TRANSIT,
            4: this.delivery_status.OUT_FOR_DELIVERY,
            5: this.delivery_status.DELIVERED,
          };
          if (dhl_status[sendung.sendungsdetails.sendungsverlauf.fortschritt] !== undefined) {
            return dhl_status[sendung.sendungsdetails.sendungsverlauf.fortschritt];
          }
        }
        if (id === 'hermes' && sendung.status) {
          const hermes_status = {
            AM_PKS_ABGEGEBEN: this.delivery_status.REGISTERED,
            1: this.delivery_status.REGISTERED,
            PAKETSHOP_AN_FAHRER_UEBERGEBEN: this.delivery_status.IN_PREPARATION,
            UNTERWEGS: this.delivery_status.IN_TRANSIT,
            ZUSTELLTOUR: this.delivery_status.OUT_FOR_DELIVERY,
            ZUGESTELLT: this.delivery_status.DELIVERED,
          };
          if (hermes_status[sendung.status.parcelStatus] !== undefined) {
            return hermes_status[sendung.status.parcelStatus];
          }
          // if (hermes_status[sendung.status.parcelStatus] !== undefined) {
          //   return hermes_status[sendung.status.parcelStatus];
          // }
        }
        if (id === 'dpd' && sendung.statusId) {
          // StatusID-Werte aus der DPD-App v4.1.2 (SOAP-Response).
          // Belege in der APK unter smali/com/dpd/navigator/{commons/Constant.smali,
          // ui/**} für: DATA_TRANSMITTED, NO_TRACKINGDATA, RETURN_TO_SENDER,
          // OUT_FOR_DELIVERY, DELIVERED. Restliche Werte (ACCEPTED, ON_THE_ROAD,
          // AT_DELIVERY_DEPOT, ...) beobachtet in Live-Response.
          const dpd_status = {
            // "Vor-Transit"
            NO_TRACKINGDATA: this.delivery_status.REGISTERED,
            DATA_TRANSMITTED: this.delivery_status.REGISTERED,
            ACCEPTED: this.delivery_status.REGISTERED,
            START: this.delivery_status.REGISTERED,
            // In Transit
            COLLECTED: this.delivery_status.IN_TRANSIT,
            AT_SENDING_DEPOT: this.delivery_status.IN_TRANSIT,
            ON_THE_ROAD: this.delivery_status.IN_TRANSIT,
            AT_DELIVERY_DEPOT: this.delivery_status.IN_TRANSIT,
            SORTED: this.delivery_status.IN_TRANSIT,
            SORTED_TO_PICKUP_LOCATION: this.delivery_status.IN_TRANSIT,
            PARCEL_PROCESSING: this.delivery_status.IN_TRANSIT,
            // Zustellung läuft
            OUT_FOR_DELIVERY: this.delivery_status.OUT_FOR_DELIVERY,
            IN_DELIVERY: this.delivery_status.OUT_FOR_DELIVERY,
            AT_PARCELSHOP: this.delivery_status.OUT_FOR_DELIVERY,
            // Endstate
            DELIVERED: this.delivery_status.DELIVERED,
            PICKED_UP: this.delivery_status.DELIVERED,
            // Rücksendung — als Endstate behandelt (keine weitere Zustellung)
            RETURN_TO_SENDER: this.delivery_status.DELIVERED,
          };
          if (dpd_status[sendung.statusId] !== undefined) {
            return dpd_status[sendung.statusId];
          }
          // Fallback: numerisch (falls doch Zahl kommt, wie beim Legacy-Web-Flow)
          const dpd_status_num = {
            0: this.delivery_status.REGISTERED,
            1: this.delivery_status.IN_PREPARATION,
            2: this.delivery_status.IN_TRANSIT,
            3: this.delivery_status.IN_TRANSIT,
            4: this.delivery_status.OUT_FOR_DELIVERY,
            5: this.delivery_status.OUT_FOR_DELIVERY,
            6: this.delivery_status.DELIVERED,
          };
          if (dpd_status_num[sendung.statusId] !== undefined) {
            return dpd_status_num[sendung.statusId];
          }
        }
        if (id === 'gls') {
          const glsStatus = classifyGlsDeliveryStatus(sendung, this.delivery_status);
          if (glsStatus !== undefined) {
            return glsStatus;
          }
        }
        if (id === 'amz' && sendung.detailedState && sendung.detailedState.shortStatus) {
          const amz_status = {
            ORDER_PLACED: this.delivery_status.REGISTERED, //ORDERED
            SHIPPING_SOON: this.delivery_status.IN_PREPARATION,
            IN_TRANSIT: this.delivery_status.IN_TRANSIT,
            OUT_FOR_DELIVERY: this.delivery_status.OUT_FOR_DELIVERY,
            DELIVERED: this.delivery_status.DELIVERED,
            PICKED_UP: this.delivery_status.DELIVERED,
          };
          if (amz_status[sendung.detailedState.shortStatus] !== undefined) {
            return amz_status[sendung.detailedState.shortStatus];
          }
        }
      }
      if (sendungsObject) {
        if (this.inDeliveryCheck(sendungsObject)) {
          return this.delivery_status.OUT_FOR_DELIVERY;
        }
        if (this.deliveredCheck(sendungsObject)) {
          return this.delivery_status.DELIVERED;
        }
      }

      return this.delivery_status.UNKNOWN;
    } catch (error) {
      this.logAxiosError('DeliveredCheck', error);
      return this.delivery_status['ERROR'];
    }
  }

  async activateToken(grant_token, url) {
    await this.requestClient({
      method: 'post',
      url: url,
      headers: {
        Accept: '*/*',
        'Content-Type': 'application/json',
      },
      data: JSON.stringify({
        grant_token: grant_token,
      }),
    })
      .then(async (res) => {
        this.log.debug(JSON.stringify(res.data));
      })
      .catch((error) => {
        this.logAxiosError('DHL/activateToken', error);
        error.response && this.log.error(JSON.stringify(error.response.data));
      });
  }
  async getAmazonPackages() {
    this.log.debug('Get Amazon Packages');
    const amzResult = { sendungen: [] };

    await this.loginAmz();
    let orders = await this.getAmazonOrders();
    if (!orders) {
      orders = await this.getAmazonOrders();
    }
    if (!orders) {
      this.log.info('No Amazon orders found');
      return;
    }
    this.log.debug('Found ' + orders.length + ' Amazon Orders');
    if (orders.length === 0) {
      // this.log.debug(res.data);
    }
    for (const order of orders) {
      if (order.url.indexOf('http') === -1) {
        order.url = 'https://www.amazon.de' + order.url;
      }
      this.log.debug(order.url);
      order.url = order.url + '';
      const element = await this.requestClient({
        method: 'get',
        url: order.url,
        headers: {
          authority: 'www.amazon.de',
          accept:
            'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
          'accept-language': 'de,en;q=0.9,es;q=0.8,hi;q=0.7,kn;q=0.6',
          'cache-control': 'no-cache',
          'device-memory': '8',
          downlink: '2',
          dpr: '2',
          ect: '4g',
          pragma: 'no-cache',
          referer: 'https://www.amazon.de/gp/css/order-history?ref_=nav_orders_first',
          rtt: '50',
          'sec-ch-device-memory': '8',
          'sec-ch-dpr': '2',
          'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
          'sec-ch-ua-mobile': '?0',
          'sec-ch-ua-platform': '"macOS"',
          'sec-ch-ua-platform-version': '"14.1.1"',
          'sec-ch-viewport-width': '1264',
          'sec-fetch-dest': 'document',
          'sec-fetch-mode': 'navigate',
          'sec-fetch-site': 'same-origin',
          'sec-fetch-user': '?1',
          'upgrade-insecure-requests': '1',
          'user-agent':
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
          'viewport-width': '1264',
        },
      })
        .then(async (res) => {
          // this.log.debug(JSON.stringify(res.data));
          const dom = new JSDOM(res.data);
          const document = dom.window.document;
          const statusHandle =
            document.querySelector('.pt-status-main-status') ||
            document.querySelector('.milestone-primaryMessage.alpha') ||
            document.querySelector('.milestone-primaryMessage') ||
            null;
          let additionalStatus = document.querySelector('#primaryStatus')
            ? document.querySelector('#primaryStatus').textContent.replace(/\n */g, '')
            : '';
          let secondaryStatus = document.querySelector('#secondaryStatus')
            ? document.querySelector('#secondaryStatus').textContent.replace(/\n */g, '')
            : '';
          if (!secondaryStatus) {
            secondaryStatus = document.querySelector('.pt-promise-details-slot')
              ? document.querySelector('.pt-promise-details-slot').textContent.replace(/\n */g, '')
              : '';
          }
          if (!secondaryStatus) {
            secondaryStatus = document.querySelector('.pt-status-secondary-status')
              ? document.querySelector('.pt-status-secondary-status').textContent.replace(/\n */g, '')
              : '';
          }
          if (!additionalStatus) {
            additionalStatus = document.querySelector('.pt-promise-main-slot')
              ? document.querySelector('.pt-promise-main-slot').textContent.replace(/\n */g, '')
              : '';
          }
          let stopsStatus = '';
          let stateObject = {};
          if (document.querySelector(`script[data-a-state='{"key":"page-state"}']`)) {
            try {
              const jsonState = document.querySelector(`script[data-a-state='{"key":"page-state"}']`).textContent;
              stateObject = JSON.parse(jsonState);
              if (stateObject.mapTracking && stateObject.mapTracking.calloutMessage) {
                stopsStatus = stateObject.mapTracking.calloutMessage;
              }
            } catch (error) {
              this.logAxiosError('Amazon/packages', error);
            }
          }

          let status = statusHandle ? statusHandle.textContent.replace(/\n */g, '') : '';
          if (!status) {
            status = stateObject.promise?.promiseMessage;
          }
          if (!status) {
            const shippingInfo = document.querySelector('.js-shipment-info-container');
            if (shippingInfo) {
              status = shippingInfo.textContent.replace(/\n */g, '');
            }
          }
          if (!status) {
            const returnInfo = document.querySelector('.a-alert-container .a-text-bold');
            if (returnInfo) {
              status = returnInfo.textContent.replace(/\n */g, '');
            }
          }
          if (!additionalStatus) {
            additionalStatus = stateObject.promise?.pdwHelpIconMessage;
          }
          if (!status) {
            status = additionalStatus;
          }
          if (additionalStatus && status !== additionalStatus) {
            status = status + '. ' + additionalStatus;
          }

          if (secondaryStatus) {
            status = status + '. ' + secondaryStatus;
          }

          if (stopsStatus) {
            status = status + '. ' + stopsStatus;
          }
          if (!status) {
            this.log.info('No status found for ' + order.url);
            this.log.debug(res.data);
            return;
          }
          if (status.includes('Erstattung') && Object.keys(stateObject).length === 0) {
            this.log.debug('No detail status found for ' + order.url);
            this.log.debug(res.data);
            return;
          }
          const id = document.querySelector('.pt-delivery-card-trackingId')
            ? document.querySelector('.pt-delivery-card-trackingId').textContent.replace('Trackingnummer ', '')
            : '';

          const name = document.querySelector('.carrierRelatedInfo-mfn-providerTitle')
            ? document.querySelector('.carrierRelatedInfo-mfn-providerTitle').textContent.replace(/\\n */g, '')
            : '';
          if (id === '' && Object.keys(stateObject).length === 0) {
            this.log.debug('No detail status found for ' + order.url);
            this.log.debug(res.data);
            return;
          }

          return {
            id: id,
            name: name,
            status: status,
            detailedState: stateObject,
          };
        })
        .catch((error) => {
          this.logAxiosError('Amazon/packages', error);
          if (error.response) {
            this.log.error(JSON.stringify(error.response.data));
          }
        });

      if (element) {
        const orderId = qs.parse(order.url).orderId;
        element.name = order.desc;
        if (!element.name && orderId) {
          element.name = orderId;
        }
        if (!element.id && orderId) {
          element.id = orderId;
        }
        this.log.debug(JSON.stringify(element));
        amzResult.sendungen.push(element);
      }
    }

    this.json2iob.parse('amazon', amzResult, { forceIndex: true });

    this.mergeProviderJson('amz', amzResult);
    await this.setStateAsync('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
    await this.setStateAsync('amazon.json', JSON.stringify(amzResult), true);
  }
  async getAmazonOrders() {
    return await this.requestClient({
      method: 'get',
      url: 'https://www.amazon.de/gp/css/order-history?ref_=nav_orders_first',
      headers: {
        authority: 'www.amazon.de',
        Connection: 'keep-alive',
        'Cache-Control': 'no-cache',
        accept:
          'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
        'accept-language': 'de-de',
        Pragma: 'no-cache',
        'Sec-Fetch-Dest': 'document',
        'Sec-Fetch-Mode': 'navigate',
        'Sec-Fetch-Site': 'none',
        'Sec-Fetch-User': '?1',
        'Upgrade-Insecure-Requests': '1',
        'User-Agent':
          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
        'device-memory': '8',
        downlink: '10',
        dpr: '2',
        ect: '4g',
        rtt: '50',
        'sec-ch-device-memory': '8',
        'sec-ch-dpr': '2',
        'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"macOS"',
        'sec-ch-ua-platform-version': '"14.1.1"',
        'sec-ch-viewport-width': '1264',
        'viewport-width': '1264',
      },
    })
      .then(async (res) => {
        // this.log.debug(JSON.stringify(res.data));
        const dom = new JSDOM(res.data);

        if (res.data.includes('auth-workflow')) {
          this.log.debug('Amazon Login required');
          this.log.debug(res.data);
          await this.loginAmz();
          return;
        }
        const document = dom.window.document;
        const elements = [];
        const orders = document.querySelectorAll('.order-card.js-order-card');

        for (const order of orders) {
          const descHandle = order.querySelector(
            '.a-fixed-right-grid-col.a-col-left .a-fixed-left-grid-col.a-col-right div:first-child .a-link-normal',
          );
          const desc = descHandle ? descHandle.textContent.replace(/\n */g, '') : '';
          let url = order.querySelector('.track-package-button a')
            ? order.querySelector('.track-package-button a').getAttribute('href')
            : '';
          if (!url) {
            const allLinks = order.querySelectorAll('.a-button-inner a');
            for (const link of allLinks) {
              if (link.textContent.includes('Lieferung verfolgen')) {
                url = link.getAttribute('href');
              }
            }
          }
          if (!url) {
            url = order.querySelector('.yohtmlc-shipment-level-connections .a-button-inner a')
              ? order.querySelector('.yohtmlc-shipment-level-connections .a-button-inner a').getAttribute('href')
              : '';
          }
          if (url) {
            elements.push({ desc: desc, url: url });
          }
        }
        return elements;
      })
      .catch((error) => {
        this.log.error('Failed to get Amazon Orders');
        this.logAxiosError('Amazon/orders', error);
        if (error.response) {
          this.log.error(JSON.stringify(error.response.data));
        }
      });
  }

  async refreshToken() {
    if (Object.keys(this.sessions).length === 0) {
      this.log.error('No session found relogin');
      return;
    }
    for (const id of Object.keys(this.sessions)) {
      if (id === 'dhl') {
        await this.requestClient({
          method: 'post',
          url: 'https://login.dhl.de/af5f9bb6-27ad-4af4-9445-008e7a5cddb8/login/token',
          headers: {
            Host: 'login.dhl.de',
            'Content-Type': 'application/x-www-form-urlencoded',
            Accept: 'application/json, text/plain, */*',
            Origin: 'https://login.dhl.de',
            Connection: 'keep-alive',
            'User-Agent': 'DHLPaket_PROD/1367 CFNetwork/1240.0.4 Darwin/20.6.0',
            'Accept-Language': 'de-de',
          },
          data: {
            client_id: '83471082-5c13-4fce-8dcb-19d2a3fca413',
            grant_type: 'refresh_token',
            refresh_token: this.sessions['dhl'].refresh_token,
          },
        })
          .then(async (res) => {
            this.log.debug(JSON.stringify(res.data));
            this.sessions['dhl'] = res.data;
            await this.cookieJar.setCookie('dhli=' + res.data.id_token + '; path=/; domain=dhl.de', 'https:/dhl.de');
            await this.cookieJar.setCookie('dhli=' + res.data.id_token + '; path=/; domain=www.dhl.de', 'https:/www.dhl.de');
            this.setState('auth.cookie', JSON.stringify(this.cookieJar.toJSON()), true);
            this.setState('auth.dhlSession', JSON.stringify(res.data), true);
            this.setState('info.connection', true, true);
          })
          .catch((error) => {
            this.log.error('refresh token failed');
            this.logAxiosError('DHL/refresh', error);
            error.response && this.log.error(JSON.stringify(error.response.data));
            this.log.error('Refresh token expired. Bitte einen neuen dhllogin:// Code in den Adaptereinstellungen eingeben.');
            delete this.sessions['dhl'];
            this.setState('auth.dhlSession', '', true);
          });
      }
      if (id === 'dpd') {
        await this.loginDPD(true);
      }
      if (id === '17tuser') {
        this.login17T(true);
      }
      if (id === 'gls') {
        this.refreshGLSToken(true);
      }
      if (id === 'ups') {
        this.loginUPS(true);
      }
      if (id === 'hermes') {
        await this.requestClient({
          method: 'post',
          url: 'https://mobile-app-api.a0930.prd.hc.de/api/v12/users/refreshtoken',
          headers: {
            'Content-Type': 'application/json; charset=utf-8',
            Accept: 'application/json',
            'api-key': 'acefe97f-89fc-4f4e-9543-fc6b90f68928',
            'User-Agent': 'Hermes - ios - 12.1.1 (2689)',
            'Accept-Language': 'de-de',
          },
          data: `{"refreshToken":"${this.sessions['hermes'].refreshToken}"}`,
        })
          .then((res) => {
            this.log.debug(JSON.stringify(res.data));
            this.hermesAuthToken = res.data.accessToken;
            this.sessions['hermes'] = res.data;
            this.setState('info.connection', true, true);
          })
          .catch((error) => {
            this.log.error('refresh token failed');
            this.logAxiosError('Hermes/refresh', error);
            error.response && this.log.error(JSON.stringify(error.response.data));
          });
      }
    }
  }
  async createDHLStates() {
    await this.setObjectNotExistsAsync('dhl', {
      type: 'device',
      common: {
        name: 'DHL Tracking',
      },
      native: {},
    });

    await this.setObjectNotExistsAsync('dhl.json', {
      type: 'state',
      common: {
        name: 'Json Sendungen',
        write: false,
        read: true,
        type: 'string',
        role: 'json',
      },
      native: {},
    });
    await this.setObjectNotExistsAsync('dhl.briefe.json', {
      type: 'state',
      common: {
        name: 'Json Briefe',
        write: false,
        read: true,
        type: 'string',
        role: 'json',
      },
      native: {},
    });
  }
  sleep(ms) {
    if (this.adapterStopped) {
      ms = 0;
    }
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
  extractFormAction(body) {
    const match = body.match(/<form[^>]*name=["']signIn["'][^>]*action=["']([^"']*)["']/i);
    if (!match) return null;
    let action = match[1].replace(/&amp;/g, '&');
    if (action.startsWith('/')) {
      action = 'https://www.amazon.de' + action;
    }
    return action;
  }
  extractHidden(body) {
    const returnObject = {};
    const matches = this.matchAll(/<input (?=[^>]* name=["']([^'"]*)|)(?=[^>]* value=["']([^'"]*)|)/g, body);
    for (const match of matches) {
      returnObject[match[1]] = match[2];
    }
    return returnObject;
  }
  matchAll(re, str) {
    let match;
    const matches = [];
    while ((match = re.exec(str))) {
      // add all matched groups
      matches.push(match);
    }

    return matches;
  }
  /**
   * Is called when adapter shuts down - callback has to be called under any circumstances!
   * @param {() => void} callback
   */
  async onUnload(callback) {
    try {
      this.setState('info.connection', false, true);
      this.reLoginTimeout && clearTimeout(this.reLoginTimeout);
      this.refreshTokenTimeout && clearTimeout(this.refreshTokenTimeout);
      this.updateInterval && clearInterval(this.updateInterval);
      this.refreshTokenInterval && clearInterval(this.refreshTokenInterval);
      //get adapter settings and set captcha to null
      if ((this.config.dhlCode && this.dhlLoginSuccess) || this.config.amzotp || this.config.amzResetCookies) {
        const adapterSettings = await this.getForeignObjectAsync('system.adapter.' + this.namespace);
        if (adapterSettings) {
          if (this.config.dhlCode && this.dhlLoginSuccess) {
            adapterSettings.native.dhlCode = null;
          }
          if (this.config.amzotp) {
            adapterSettings.native.amzotp = '';
          }
          if (this.config.amzResetCookies) {
            adapterSettings.native.amzResetCookies = false;
          }
          await this.setForeignObjectAsync('system.adapter.' + this.namespace, adapterSettings);
        }
      }
      callback();
    } catch (e) {
      this.log.error('Error onUnload: ' + e);
      callback();
    }
  }

  /**
   * Is called if a subscribed state changes
   * @param {string} id
   * @param {ioBroker.State | null | undefined} state
   */
  async onStateChange(id, state) {
    if (state) {
      if (!state.ack) {
        if (id.split('.')[2] === 'refresh') {
          this.updateProvider();
          return;
        }
        if (id.split('.')[2] === '17t') {
          if (!this.config['17trackKey']) {
            this.log.error('Missing 17Track Security Key');
            return;
          }
          const command = id.split('.')[3];
          await this.requestClient({
            method: 'post',
            url: 'https://api.17track.net/track/v1/' + command,
            headers: {
              '17token': this.config['17trackKey'],
              'Content-Type': 'application/json',
            },
            data: JSON.stringify([
              {
                number: state.val,
                auto_detection: true,
              },
            ]),
          })
            .then(async (res) => {
              this.log.debug(JSON.stringify(res.data));
              await this.requestClient({
                method: 'post',
                url: 'https://api.17track.net/track/v1/gettracklist',
                headers: {
                  '17token': this.config['17trackKey'],
                  'Content-Type': 'application/json',
                },
                data: {
                  number: state.val,
                  auto_detection: true,
                },
              })
                .then(async (res) => {
                  this.log.debug(JSON.stringify(res.data));
                  if (res.data && res.data.data && res.data.data.accepted) {
                    const trackArray = [];
                    for (const track of res.data.data.accepted) {
                      trackArray.push(track.number);
                    }
                    this.setState('17t.trackList', JSON.stringify(trackArray), true);
                  }
                })
                .catch((error) => {
                  this.logAxiosError('17Track/track', error);
                  if (error.response) {
                    this.log.error(JSON.stringify(error.response.data));
                  }
                });
            })
            .catch((error) => {
              this.logAxiosError('17Track/track', error);
              if (error.response) {
                this.log.error(JSON.stringify(error.response.data));
              }
            });
        }
        if (id.split('.')[2] === '17tuser') {
          await this.requestClient({
            method: 'post',
            url: 'https://buyer.17track.net/orderapi/call',
            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
            data: JSON.stringify({
              version: '1.0',
              timeZoneOffset: -60,
              method: 'AddTrackNo',
              param: { TrackNos: [state.val] },
            }),
          })
            .then(async (res) => {
              this.log.info(JSON.stringify(res.data));
              this.updateProvider();
            })
            .catch((error) => {
              this.logAxiosError('17Track/order', error);
              if (error.response) {
                this.log.error(JSON.stringify(error.response.data));
              }
            });
        }
      } else {
        if (id.indexOf('dhl.briefe') !== -1 && id.indexOf('image_url') !== -1 && id.indexOf('oldAdvices') === -1) {
          let imageBase64 = this.images[state.val];
          if (!imageBase64) {
            // const image = await this.requestClient({
            //   method: 'get',
            //   url: state.val,
            //   responseType: 'arraybuffer',
            // }).catch((error) => {
            //   if (error.response && error.response.status === 401) {
            //     this.log.debug(error);
            //     return;
            //   }
            //   this.log.error(state.val + ' ' + error);
            // });
            const image = await dhlDecrypt(state.val, this.requestClient).catch((error) => {
              if (error.response && error.response.status === 401) {
                this.log.debug(error);
                return;
              }
              this.log.error(state.val + ' ' + error);
            });
            if (!image) {
              this.log.debug('No image received for ' + state.val);
              return;
            }
            const imageBuffer = Buffer.from(image, 'binary');
            imageBase64 = 'data:image/png;base64, ' + imageBuffer.toString('base64');
            this.images[state.val] = imageBase64;
            const pathArray = id.split('.');
            pathArray.pop();
            pathArray.push('image');
            await this.extendObjectAsync(pathArray.join('.'), {
              type: 'state',
              common: {
                name: 'Image Base64 Decrypted from URL',
                write: false,
                read: true,
                type: 'string',
                role: 'state',
              },
              native: {},
            });

            this.setState(pathArray.join('.'), imageBase64, true);
            if (this.config.sendToActive) {
              if (this.config.noFirstStartSend && this.firstStart) {
                return;
              }
              const uuid = crypto.randomUUID();
              fs.writeFileSync(`${this.tmpDir}${sep}${uuid}.jpg`, imageBuffer.toString('base64'), 'base64');
              const sendInstances = this.config.sendToInstance.replace(/ /g, '').split(',');
              const sendUser = this.config.sendToUser.replace(/ /g, '').split(',');

              for (const sendInstance of sendInstances) {
                if (sendUser.length > 0) {
                  for (const user of sendUser) {
                    if (sendInstance.includes('pushover')) {
                      await this.sendToAsync(sendInstance, {
                        device: user,
                        file: `${this.tmpDir}${sep}${uuid}.jpg`,
                        title: '✉️Briefankündigung',
                      });
                    } else if (sendInstance.includes('signal-cmb')) {
                      await this.sendToAsync(sendInstance, 'send', {
                        text: '✉️Briefankündigung',
                        phone: user,
                      });
                    } else {
                      await this.sendToAsync(sendInstance, {
                        user: user,
                        text: '✉️Briefankündigung',
                      });
                      await this.sendToAsync(sendInstance, {
                        user: user,
                        text: `${this.tmpDir}${sep}${uuid}.jpg`,
                      });
                    }
                  }
                } else {
                  if (sendInstance.includes('pushover')) {
                    await this.sendToAsync(sendInstance, {
                      file: `${this.tmpDir}${sep}${uuid}.jpg`,
                      title: '✉️Briefankündigung',
                    });
                  } else if (sendInstance.includes('signal-cmb')) {
                    await this.sendToAsync(sendInstance, 'send', {
                      text: '✉️Briefankündigung',
                    });
                  } else {
                    await this.sendToAsync(sendInstance, '✉️Briefankündigung');
                    await this.sendToAsync(sendInstance, `${this.tmpDir}${sep}${uuid}.jpg`);
                  }
                }
              }
              try {
                fs.unlinkSync(`${this.tmpDir}${sep}${uuid}.jpg`);
              } catch (error) {
                this.log.debug('unlink temp image failed: ' + (error && error.message));
              }
            }
          } else {
            await this.extendObjectAsync(id.replace('image_url', 'image'), {
              type: 'state',
              common: {
                name: 'Image Base64 Decrypted from URL',
                write: false,
                read: true,
                type: 'string',
                role: 'state',
              },
              native: {},
            });
            this.setState(id.replace('image_url', 'image'), imageBase64, true);
          }
        }
      }
    }
  }
}

if (require.main !== module) {
  // Export the constructor in compact mode
  /**
   * @param {Partial<utils.AdapterOptions>} [options={}]
   */
  module.exports = (options) => new Parcel(options);
} else {
  // otherwise start the instance directly
  new Parcel();
}