@alizadefaig/pos-server 1.2.28 → 1.2.31

package/app/sync/discovery.js

@@ -170,9 +170,15 @@ const buildAnswer = ({nonce, httpPort, identity}) => {
  * Проверка ответа мастера (UDP и HTTP). address — откуда ответ пришёл на самом деле: он обязан
  * быть в подписанных hosts. port — если известен (HTTP): мастер обязан назвать тот же.
  */
-const accept = (message, {key, nonce, address, companyId = null, port = null}) => {
-    if (!message || message.t !== ANSWER || message.nonce !== nonce) {
-        return null;
+const check = (message, {key, nonce, address, companyId = null, port = null}) => {
+    if (!message) {
+        return 'bad_packet';
+    }
+    if (message.t !== ANSWER) {
+        return 'not_answer';
+    }
+    if (message.nonce !== nonce) {
+        return 'stale_nonce';
     }
     const hosts = Array.isArray(message.hosts) ? message.hosts.map(String) : [];
     const fields = {
@@ -183,16 +189,20 @@ const accept = (message, {key, nonce, address, companyId = null, port = null}) =
         hosts,
     };
     if (!Number.isInteger(fields.port) || fields.port <= 0 || fields.port > 65535) {
-        return null;
+        return 'bad_port';
     }
     if (port !== null && fields.port !== port) {
-        return null;
+        return 'port_mismatch';
     }
-    if (!hosts.includes(address) || !proofMatches(key, fields, message.proof)) {
-        return null;
+    if (!hosts.includes(address)) {
+        return 'address_not_in_hosts';
+    }
+    // Другой ключ зала: мастер и ведомый настроены разными ключами (смена ключа не доехала).
+    if (!proofMatches(key, fields, message.proof)) {
+        return 'bad_proof';
     }
     if (companyId && fields.company_id !== companyId) {
-        return null;
+        return 'other_company';
     }
     return {
         url: `http://${address}:${fields.port}`,
@@ -203,8 +213,31 @@ const accept = (message, {key, nonce, address, companyId = null, port = null}) =
     };
 };
 
+const accept = (message, options) => {
+    const result = check(message, options);
+    return typeof result === 'string' ? null : result;
+};
+
+const bump = (map, key) => {
+    map[key] = (map[key] || 0) + 1;
+};
+
 // ---------------------------------------------------------------- мастер: отвечает
 
+/** Почему buildAnswer вернул null — для диагностики. */
+const noAnswerReason = (identity) => {
+    if (!config.lanKey()) {
+        return 'no_lan_key';
+    }
+    if (!identity || !identity.company_id) {
+        return 'no_session';
+    }
+    if (!interfaces().length) {
+        return 'no_interfaces';
+    }
+    return 'bad_nonce';
+};
+
 class Responder {
     /**
      * @param {{httpPort: () => number, identity: () => ({company_id, terminal_id}|null)}} options
@@ -217,6 +250,13 @@ class Responder {
         this.socket = null;
         this.answered = 0;
         this.limiter = new Limiter(MAX_ANSWERS_PER_SECOND);
+        // Диагностика (/local/status.discovery): доходят ли запросы ведомых до мастера.
+        this.received = 0;
+        this.rejected = {};
+        this.sendErrors = 0;
+        this.lastQuery = null;
+        this.bound = null;
+        this.error = null;
     }
 
     start() {
@@ -228,12 +268,20 @@ class Responder {
         const socket = dgram.createSocket('udp4');
         socket.on('error', (e) => {
             console.warn('[discovery] responder error:', e.message);
+            this.error = `${e.code || ''} ${e.message}`.trim();
             this.stop();
         });
         socket.on('message', (buffer, rinfo) => {
+            this.received += 1;
+            this.lastQuery = {from: rinfo.address, at: new Date().toISOString()};
             this.answer(socket, parse(buffer), rinfo).catch(() => {});
         });
-        socket.bind(port, () => log(`answering on udp/${port}`));
+        socket.bind(port, () => {
+            const address = socket.address();
+            this.bound = `${address.address}:${address.port}`;
+            this.error = null;
+            log(`answering on udp/${port}`);
+        });
         socket.unref();
         this.socket = socket;
         return this;
@@ -241,19 +289,40 @@ class Responder {
 
     async answer(socket, message, rinfo) {
         if (!message || message.t !== QUERY) {
+            bump(this.rejected, 'bad_packet');
             return;
         }
         const identity = this.identity();
         // Ведомый другого заведения в той же сети — не наш.
         if (identity && message.company_id && message.company_id !== identity.company_id) {
+            bump(this.rejected, 'other_company');
             return;
         }
         const answer = buildAnswer({nonce: message.nonce, httpPort: this.httpPort(), identity});
-        if (!answer || !this.limiter.take()) {
+        if (!answer) {
+            bump(this.rejected, noAnswerReason(identity));
+            return;
+        }
+        if (!this.limiter.take()) {
+            bump(this.rejected, 'rate_limited');
             return;
         }
         this.answered += 1;
-        await send(socket, answer, rinfo.port, rinfo.address);
+        if (!await send(socket, answer, rinfo.port, rinfo.address)) {
+            this.sendErrors += 1;
+        }
+    }
+
+    status() {
+        return {
+            bound: this.bound,
+            error: this.error,
+            received: this.received,
+            answered: this.answered,
+            rejected: this.rejected,
+            send_errors: this.sendErrors,
+            last_query: this.lastQuery,
+        };
     }
 
     stop() {
@@ -271,21 +340,37 @@ class Responder {
 
 const httpLimiter = new Limiter(MAX_ANSWERS_PER_SECOND);
 let httpAnswered = 0;
+const httpStats = {requests: 0, rejected: {}, last: null};
 
 /**
  * GET /local/whoami?nonce= — тот же подписанный ответ по HTTP (ступени 1 и 3 поиска). Путь
  * открыт без ключа зала (lan.js): ответ сам доказывает знание ключа и ничего не раскрывает.
  * null — не отвечаем (не мастер, нет ключа или сессии, превышен лимит).
  */
-const whoami = ({nonce, httpPort, identity}) => {
+const whoami = ({nonce, httpPort, identity, from = null}) => {
+    httpStats.requests += 1;
+    httpStats.last = {from, at: new Date().toISOString()};
     const answer = buildAnswer({nonce, httpPort, identity});
-    if (!answer || !httpLimiter.take()) {
+    if (!answer) {
+        bump(httpStats.rejected, noAnswerReason(identity));
+        return null;
+    }
+    if (!httpLimiter.take()) {
+        bump(httpStats.rejected, 'rate_limited');
         return null;
     }
     httpAnswered += 1;
     return answer;
 };
 
+/** Счётчики /local/whoami мастера: доходят ли HTTP-проверки ведомых. */
+const whoamiStatus = () => ({
+    requests: httpStats.requests,
+    answered: httpAnswered,
+    rejected: {...httpStats.rejected},
+    last: httpStats.last,
+});
+
 // ---------------------------------------------------------------- ведомый: ищет
 
 /**
@@ -295,9 +380,12 @@ const whoami = ({nonce, httpPort, identity}) => {
  * @param {{companyId?: string, targets?: string[]}} options
  *   targets — куда слать вместо широковещательных адресов (тесты, сети без broadcast).
  */
-const probe = ({companyId = null, targets = null} = {}) => new Promise((resolve) => {
+const probe = ({companyId = null, targets = null, stats = null} = {}) => new Promise((resolve) => {
     const key = config.lanKey();
     if (!key) {
+        if (stats) {
+            stats.error = 'no_lan_key';
+        }
         resolve([]);
         return;
     }
@@ -321,12 +409,24 @@ const probe = ({companyId = null, targets = null} = {}) => new Promise((resolve)
     };
     const timer = setTimeout(finish, window);
 
-    socket.on('error', finish);
+    socket.on('error', (e) => {
+        if (stats) {
+            stats.error = `${e.code || ''} ${e.message}`.trim();
+        }
+        finish();
+    });
     socket.on('message', (buffer, rinfo) => {
-        const candidate = accept(parse(buffer), {key, nonce, address: rinfo.address, companyId});
-        if (candidate) {
-            found.set(rinfo.address, candidate);
+        const result = check(parse(buffer), {key, nonce, address: rinfo.address, companyId});
+        if (stats) {
+            stats.answers += 1;
+        }
+        if (typeof result === 'string') {
+            if (stats && Object.keys(stats.rejected).length < 20) {
+                bump(stats.rejected, `${result}@${rinfo.address}`);
+            }
+            return;
         }
+        found.set(rinfo.address, result);
     });
     socket.bind(0, async () => {
         socket.setBroadcast(true);
@@ -334,7 +434,12 @@ const probe = ({companyId = null, targets = null} = {}) => new Promise((resolve)
         const addresses = targets && targets.length
             ? targets
             : [...new Set([...interfaces().map((item) => item.broadcast), '255.255.255.255'])];
-        await Promise.all(addresses.map((address) => send(socket, message, port, address)));
+        const results = await Promise.all(addresses.map((address) => send(socket, message, port, address)));
+        if (stats) {
+            stats.targets = addresses;
+            stats.sent = results.filter(Boolean).length;
+            stats.send_errors = results.length - stats.sent;
+        }
     });
 });
 
@@ -342,16 +447,34 @@ const probe = ({companyId = null, targets = null} = {}) => new Promise((resolve)
  * Проверка адреса по HTTP: GET <url>/local/whoami со свежим nonce. Отдаёт кандидата или null.
  * Только http и IPv4 — подпись мастера перечисляет его IPv4, по имени хоста её не сверить.
  */
-const verify = async (url, {companyId = null, timeout = VERIFY_TIMEOUT_MS} = {}) => {
+const verify = async (url, options = {}) => {
+    const result = await verifyWhy(url, options);
+    return typeof result === 'string' ? null : result;
+};
+
+/** Сетевая ошибка fetch → короткий код: timeout, ECONNREFUSED, EHOSTUNREACH, … */
+const fetchError = (e) => {
+    if (e && e.name === 'AbortError') {
+        return 'timeout';
+    }
+    const cause = e && e.cause;
+    return (cause && (cause.code || cause.name)) || (e && (e.code || e.name)) || 'error';
+};
+
+/** Как verify, но вместо null — причина отказа строкой (для диагностики). */
+const verifyWhy = async (url, {companyId = null, timeout = VERIFY_TIMEOUT_MS} = {}) => {
     const key = config.lanKey();
     let target;
     try {
         target = new URL(url);
     } catch (e) {
-        return null;
+        return 'bad_url';
     }
-    if (!key || target.protocol !== 'http:' || !IPV4.test(target.hostname)) {
-        return null;
+    if (!key) {
+        return 'no_lan_key';
+    }
+    if (target.protocol !== 'http:' || !IPV4.test(target.hostname)) {
+        return 'bad_url';
     }
     const port = Number(target.port || 80);
     const nonce = randomBytes(16).toString('hex');
@@ -363,12 +486,12 @@ const verify = async (url, {companyId = null, timeout = VERIFY_TIMEOUT_MS} = {})
             redirect: 'error',
         });
         if (!response.ok) {
-            return null;
+            return `http_${response.status}`;
         }
         const body = Buffer.from(await response.arrayBuffer());
-        return accept(parse(body), {key, nonce, address: target.hostname, companyId, port});
+        return check(parse(body), {key, nonce, address: target.hostname, companyId, port});
     } catch (e) {
-        return null;
+        return fetchError(e);
     } finally {
         clearTimeout(timer);
     }
@@ -378,12 +501,30 @@ const verify = async (url, {companyId = null, timeout = VERIFY_TIMEOUT_MS} = {})
  * Скан подсети по HTTP пачками по SCAN_BATCH. Останавливается на первой пачке, где кто-то
  * ответил. hosts — вместо своей подсети (тесты).
  */
-const scan = async ({companyId = null, hosts = null, port = settings().httpPort} = {}) => {
+const scan = async ({companyId = null, hosts = null, port = settings().httpPort, stats = null} = {}) => {
     const list = hosts || subnetHosts();
+    if (stats) {
+        stats.hosts = list.length;
+        stats.first = list[0] || null;
+        stats.last = list[list.length - 1] || null;
+    }
     for (let i = 0; i < list.length; i += SCAN_BATCH) {
-        const answers = await Promise.all(list.slice(i, i + SCAN_BATCH)
-            .map((host) => verify(`http://${host}:${port}`, {companyId, timeout: SCAN_TIMEOUT_MS})));
-        const found = answers.filter(Boolean);
+        const batch = list.slice(i, i + SCAN_BATCH);
+        const answers = await Promise.all(batch
+            .map((host) => verifyWhy(`http://${host}:${port}`, {companyId, timeout: SCAN_TIMEOUT_MS})));
+        if (stats) {
+            answers.forEach((answer, index) => {
+                if (typeof answer !== 'string') {
+                    return;
+                }
+                bump(stats.errors, answer);
+                // Кто-то ответил по HTTP, но не как наш мастер — адрес интересен: возможно, это он.
+                if (answer !== 'timeout' && answer !== 'ECONNREFUSED' && stats.responded.length < 10) {
+                    stats.responded.push(`${batch[index]}:${answer}`);
+                }
+            });
+        }
+        const found = answers.filter((answer) => typeof answer !== 'string');
         if (found.length) {
             return found;
         }
@@ -420,6 +561,9 @@ class Finder {
         this.lastFoundAt = null;
         this.candidates = [];
         this.conflict = false;
+        this.searches = 0;
+        this.lastSearch = null;
+        this.lastScan = null;
     }
 
     start() {
@@ -468,30 +612,44 @@ class Finder {
 
     async search() {
         this.lastProbeAt = new Date().toISOString();
+        this.searches += 1;
         const companyId = this.companyId();
         let candidates = [];
         let via = null;
+        // Диагностика: что дала каждая ступень последнего поиска.
+        const report = {at: this.lastProbeAt, company_id: companyId, known: {}, udp: null};
         // 1. известный адрес: текущий или сохранённый с прошлого запуска
         const known = [...new Set([this.current, this.remembered()].filter(Boolean))];
         for (const url of known) {
-            const candidate = await verify(url, {companyId});
-            if (candidate) {
-                candidates = [candidate];
-                via = 'saved';
-                break;
+            const candidate = await verifyWhy(url, {companyId});
+            if (typeof candidate === 'string') {
+                report.known[url] = candidate;
+                continue;
             }
+            report.known[url] = 'ok';
+            candidates = [candidate];
+            via = 'saved';
+            break;
         }
         // 2. широковещательный запрос
         if (!candidates.length && !this.stopped) {
-            candidates = await probe({companyId, targets: this.targets});
+            const stats = {targets: [], sent: 0, send_errors: 0, answers: 0, rejected: {}, error: null};
+            candidates = await probe({companyId, targets: this.targets, stats});
+            report.udp = stats;
             via = 'udp';
         }
         // 3. скан подсети — широковещание могло не дойти (фильтр точки доступа, брандмауэр)
         if (!candidates.length && !this.stopped && this.scanDue()) {
             this.lastScanAt = Date.now();
-            candidates = await scan({companyId, hosts: this.scanHosts});
+            const stats = {at: new Date().toISOString(), hosts: 0, first: null, last: null,
+                errors: {}, responded: [], found: 0};
+            candidates = await scan({companyId, hosts: this.scanHosts, stats});
+            stats.found = candidates.length;
+            this.lastScan = stats;
             via = 'scan';
         }
+        report.found = candidates.map((c) => c.url);
+        this.lastSearch = report;
         if (this.stopped) {
             return;
         }
@@ -532,6 +690,10 @@ class Finder {
             conflict: this.conflict,
             via: this.via,
             last_scan_at: this.lastScanAt ? new Date(this.lastScanAt).toISOString() : null,
+            searches: this.searches,
+            interfaces: interfaces(),
+            last_search: this.lastSearch,
+            last_scan: this.lastScan,
         };
     }
 
@@ -543,4 +705,5 @@ class Finder {
 
 const httpAnswers = () => httpAnswered;
 
-module.exports = {Responder, Finder, probe, verify, scan, whoami, httpAnswers, sign, interfaces, settings};
+module.exports = {Responder, Finder, probe, verify, verifyWhy, scan, whoami, whoamiStatus, httpAnswers, sign,
+    interfaces, settings};

package/app/sync/index.js

@@ -7,6 +7,7 @@ const {CloudSignal} = require('./signal');
 const {MasterBridge} = require('./bridge');
 const {lanHeaders} = require('./lan');
 const discovery = require('./discovery');
+const netstats = require('../netstats');
 const lanDevices = require('./lanDevices');
 const lanFront = require('./lanFront');
 const {getConfig} = require('../config');
@@ -100,9 +101,7 @@ const state = {
     // чеки, которые облако просит перечитать (sync:pull)
     pullIds: new Set(),
 
-    // выход терминала (logout): с какого момента облако на связи, а очередь ещё не пуста;
-    // идёт отзыв токена — возврат на кассу (resume) в это время невозможен
-    revokeWaitFrom: null,
+    // выход терминала (logout): идёт отзыв токена — возврат на кассу (resume) в это время невозможен
     revoking: false,
 
     // сверка касса ↔ облако (reconcile.js): последний итог, расхождений подряд, сколько вылечено
@@ -386,10 +385,12 @@ const authoritativeEpoch = () => (
         : null
 );
 
-const runPush = async () => {
+// until — выход терминала: досылать, пока облако отвечает (без гистерезиса), не дольше этого срока.
+const runPush = async ({until = null} = {}) => {
     let rounds = 0;
     reconcilePoison();
-    while (refreshPending() > 0 && rounds < MAX_PUSH_ROUNDS && state.online) {
+    const going = () => (until === null ? state.online : state.oks > 0 && Date.now() < until);
+    while (refreshPending() > 0 && rounds < MAX_PUSH_ROUNDS && going()) {
         rounds += 1;
         const epoch = authoritativeEpoch();
         let result;
@@ -1125,8 +1126,8 @@ const startDiscovery = () => {
 };
 
 /** Ответ мастера на GET /local/whoami (ступени поиска ведомого). null — 404. */
-const whoami = (nonce) => (config.role() === 'master' && state.started
-    ? discovery.whoami({nonce, httpPort: getConfig().port, identity: state.session})
+const whoami = (nonce, from = null) => (config.role() === 'master' && state.started
+    ? discovery.whoami({nonce, httpPort: getConfig().port, identity: state.session, from})
     : null);
 
 /**
@@ -1244,7 +1245,6 @@ const setSession = async (input) => {
         // Фронт снова прислал сессию — значит, терминал вошёл обратно (resume).
         delete state.session.parked;
     }
-    state.revokeWaitFrom = null;
     return {success: true, mode: state.mode};
 };
 
@@ -1260,7 +1260,6 @@ const clearSession = async () => {
     }
     stopComponents();
     state.session = null;
-    state.revokeWaitFrom = null;
     await state.store.block((s) => kv.del(s, 'session'));
     updateMode();
     return {success: true};
@@ -1273,12 +1272,12 @@ const clearSession = async () => {
  * (auth.logoutApp) и стирал сессию синка: без интернета выход падал, а недосланное
  * ждало следующего входа, которого без интернета не бывает (app.auth — только облако).
  *
- * Теперь выход «паркует» сессию: фронт свою авторизацию стирает, а синк токен держит, пока
- * он нужен, — досылает очередь, а мастер модели M продолжает обслуживать зал. Токен
- * отзывается, когда облако на связи, очередь пуста и касса не держит заведение
- * (очередь не опустела за OFFLINE_LOGOUT_GRACE_MS — отзыв всё равно, недосланное уйдёт со
- * следующим входом в это заведение). До отзыва на кассу можно вернуться по PIN сотрудника
- * (resume) — это единственный вход без облака.
+ * Теперь выход «паркует» сессию: фронт свою авторизацию стирает, а синк держит токен до
+ * первого ответа облака. Облако ответило (гистерезис связи не ждём) — синк досылает очередь не
+ * дольше OFFLINE_LOGOUT_DRAIN_MS и отзывает токен в любом случае, в том числе на мастере модели M
+ * (заведение он после этого не обслуживает). Недосланное остаётся помеченным и уйдёт со
+ * следующим входом в это заведение на этой кассе. До отзыва на кассу можно вернуться по PIN
+ * сотрудника (resume) — это единственный вход без облака.
  */
 
 const initNames = () => {
@@ -1324,8 +1323,11 @@ const revokeToken = async (client, data = {}, timeout = config.timeouts().api) =
     }
 };
 
+// Облако ответило на последнюю проверку связи: для выхода гистерезис не ждём.
+const cloudAnswers = () => state.oks > 0;
+
 const canRevokeParked = () => Boolean(state.session && state.session.parked && state.cloud)
-    && state.online === true && !state.revoking && !isServingAsMaster();
+    && cloudAnswers() && !state.revoking;
 
 /** Отзыв токена запаркованной сессии. Вернулись на кассу, пока шёл запрос, — сессию не трогаем. */
 const revokeParked = async (timeout) => {
@@ -1347,16 +1349,20 @@ const revokeParked = async (timeout) => {
 
 const runRevoke = async () => {
     if (!canRevokeParked()) {
-        state.revokeWaitFrom = null;
         return;
     }
-    if (refreshPending() > 0) {
-        state.revokeWaitFrom = state.revokeWaitFrom || Date.now();
-        if (Date.now() - state.revokeWaitFrom < config.intervals().logoutGrace) {
+    if (!isFollower() && hasInit() && refreshPending() > 0) {
+        await step('logout push', () => runPush({until: Date.now() + config.intervals().logoutDrain}));
+        if (!canRevokeParked()) {
             return;
         }
-        console.warn(`[sync] logout: ${state.pending} unsent record(s) still queued after the grace period — `
-            + 'revoking the token anyway, they wait for the next login to this company');
+        if (refreshPending() > 0) {
+            console.warn(`[sync] logout: ${state.pending} unsent record(s) left — revoking the token anyway, `
+                + 'they wait for the next login to this company');
+        }
+    }
+    if (isServingAsMaster()) {
+        console.warn('[sync] terminal logged out on the master — the company is not served after the token is revoked');
     }
     await revokeParked();
 };
@@ -1376,7 +1382,7 @@ const runLogoutQueue = async () => {
 };
 
 const runLogout = async () => {
-    if (state.online === true && state.store && (kv.get(state.store, 'logout_queue') || []).length) {
+    if (cloudAnswers() && state.store && (kv.get(state.store, 'logout_queue') || []).length) {
         await step('logout queue', runLogoutQueue);
     }
     await step('revoke', runRevoke);
@@ -1402,9 +1408,7 @@ const logout = async ({token} = {}) => {
     if (canRevokeParked() && refreshPending() === 0 && await revokeParked(REVOKE_TIMEOUT_MS)) {
         return {success: true, handled: true, revoked: true};
     }
-    if (isServingAsMaster()) {
-        console.warn('[sync] terminal logged out on the master — the company is still served, token kept');
-    }
+    // Очередь не пуста или облако не ответило — досылка и отзыв идут в цикле сразу же.
     schedule(0);
     return {success: true, handled: true, parked: true, pending: state.pending, master: isServingAsMaster()};
 };
@@ -1438,7 +1442,7 @@ const resume = async ({code} = {}) => {
     const key = throttleKey(session.team_id, session.terminal_id);
     unlockThrottle.assertAllowed(key);
     const user = code
-        ? await findUnlockUser(state.store, Array.isArray(blob.users) ? blob.users : [], code, blob.pin_salt)
+        ? await findUnlockUser(state.store, Array.isArray(blob.users) ? blob.users : [], code, blob.pin_salt, blob.terminal)
         : null;
     if (!user) {
         unlockThrottle.fail(key);
@@ -1450,7 +1454,6 @@ const resume = async ({code} = {}) => {
         throw busy();
     }
     delete session.parked;
-    state.revokeWaitFrom = null;
     await state.store.block((s) => kv.set(s, 'session', {...session}));
     log('terminal logged back in by PIN');
     return {
@@ -1523,6 +1526,10 @@ const status = () => {
 
     const result = {
         enabled,
+        // Фронт деплоится раньше, чем pos-server доезжает до касс: по версии и списку событий
+        // ядра он понимает, что этот Node умеет офлайн (лениво: ядро само требует app/sync).
+        version: PACKAGE_VERSION,
+        core_events: require('../core').offlineEvents(),
         mode: enabled ? state.mode : 'cloud',
         role: config.role(),
         session: Boolean(state.session),
@@ -1574,12 +1581,16 @@ const status = () => {
             ready: Boolean(state.signal && state.signal.relayReady),
         };
         result.discovery = state.responder
-            ? {port: discovery.settings().port, answering: Boolean(state.responder.socket), answered: state.responder.answered}
+            ? {port: discovery.settings().port, answering: Boolean(state.responder.socket),
+                answered: state.responder.answered, udp: state.responder.status(),
+                whoami: discovery.whoamiStatus(), interfaces: discovery.interfaces()}
             : null;
         result.lan = config.isLanFrontEnabled()
             ? {urls: lanFront.urls(getConfig().port), front: lanFront.status(), devices: lanDevices.status()}
             : null;
     }
+    // Слушает ли Node на 0.0.0.0 и доходят ли до него соединения из зала (app/netstats.js).
+    result.net = netstats.snapshot();
     return result;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@alizadefaig/pos-server",
-    "version": "1.2.28",
+    "version": "1.2.31",
     "description": "Server in express js with Proxy to Main server if need and will work with Electron JS",
     "homepage": "https://gitlab.com/faigalizade/pos-server#readme",
     "bugs": {

package/routes/desktop/api/offline.js

@@ -99,7 +99,7 @@ registerOfflineRoutes(router, '/api', {
         const key = throttleKey(context.teamId, context.terminalId);
         unlockThrottle.assertAllowed(key);
         const blob = readInit();
-        const user = await findUnlockUser(db, Array.isArray(blob.users) ? blob.users : [], code, blob.pin_salt);
+        const user = await findUnlockUser(db, Array.isArray(blob.users) ? blob.users : [], code, blob.pin_salt, blob.terminal);
         if (!user) {
             unlockThrottle.fail(key);
             return null;