@alizadefaig/pos-server 1.2.29 → 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');
@@ -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);
 
 /**
@@ -1441,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);
@@ -1525,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),
@@ -1576,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.29",
+    "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;

package/routes/desktop/api/printers.js

@@ -16,18 +16,40 @@ const appConfig = getConfig();
 let PROXY_TARGET = appConfig.apiUrl || 'http://localhost:8000';
 const getUsbPrinters = async () => {
     let result = [];
-    const usbDevices = escpos.USB.findPrinter();
+    let usbDevices = [];
+    try {
+        usbDevices = escpos.USB.findPrinter();
+    } catch (e) {
+        console.warn('[printers] usb scan failed:', e.message);
+        return result;
+    }
     for (const usbDevice of usbDevices) {
-        usbDevice.open((error) => {
-            console.log(error)
-        });
-        result.push({
-            type: 'USB',
-            name: await getStringDescriptor(usbDevice, usbDevice.deviceDescriptor.iProduct),
-            vendor_id: usbDevice.deviceDescriptor.idVendor,
-            product_id: usbDevice.deviceDescriptor.idProduct
-        });
-        usbDevice.close();
+        const {idVendor, idProduct, iProduct} = usbDevice.deviceDescriptor;
+        const printer = {type: 'USB', name: null, vendor_id: idVendor, product_id: idProduct};
+        // На Windows libusb открывает только устройство на драйвере WinUSB. Принтер на родном
+        // драйвере (usbprint.sys / драйвер производителя) даёт LIBUSB_ERROR_NOT_SUPPORTED —
+        // раньше это исключение роняло весь скан в 500, и не было видно даже LAN-принтеров.
+        let opened = false;
+        try {
+            usbDevice.open();
+            opened = true;
+            printer.name = await getStringDescriptor(usbDevice, iProduct);
+        } catch (e) {
+            printer.error = e.message;
+            console.warn(`[printers] usb ${idVendor}:${idProduct} not opened:`, e.message);
+        } finally {
+            if (opened) {
+                try {
+                    usbDevice.close();
+                } catch (e) {
+                }
+            }
+        }
+        if (!printer.name) {
+            const hex = (n) => Number(n).toString(16).padStart(4, '0');
+            printer.name = `USB ${hex(idVendor)}:${hex(idProduct)}`;
+        }
+        result.push(printer);
     }
 
     return result;

package/routes/desktop/local.js

@@ -61,7 +61,7 @@ router.get('/local/status', (req, res) => {
 
 // Ведомый ищет мастера (app/sync/discovery.js): подписанный ответ на nonce, без ключа зала.
 router.get('/local/whoami', (req, res) => {
-    const answer = isSyncEnabled() ? sync.whoami(req.query.nonce) : null;
+    const answer = isSyncEnabled() ? sync.whoami(req.query.nonce, String(req.socket.remoteAddress || '').replace(/^::ffff:/, '')) : null;
     if (!answer) {
         return res.status(404).json({success: false});
     }

package/routes/server/api/platform.js

@@ -17,7 +17,7 @@ const init = (services) => new InitService(services);
 
 registerOfflineRoutes(router, '/api', {
     /** AuthController::init. `user` в ответ не входит: токен кладётся в модель и не выводится. */
-    'app.init': [CLOUD_READ, async (services) => init(services).init()],
+    'app.init': [CLOUD_READ, async (services, params, extra) => init(services).init(extra)],
 
     /** ProductController::get / OrderProductController::get — оба ProductService::allProducts. */
     'products.get': [CLOUD_READ, async (services) => init(services).products(services.context.teamId)],

package/server.js

@@ -13,6 +13,7 @@ const {internalGuard, originGuard} = require("./app/security");
 const {isSyncEnabled} = require("./app/sync/config");
 const multer = require('multer');
 const {getLogger} = require("./app/logger/Log");
+const netstats = require("./app/netstats");
 
 
 
@@ -69,6 +70,8 @@ const bodyParsers = [
     express.urlencoded({extended: true, limit: BODY_LIMIT}),
     upload.any(),
 ];
+// Запросы из зала (не loopback) и их исход — для диагностики кассы (/local/status.net).
+app.use(netstats.middleware);
 // Мастер раздаёт фронт телефонам зала (LAN_FRONT): страница и её файлы открыты без ключа и
 // токена — данных в них нет, а API за ними проверяется ниже. No-op без флага.
 app.use(require('./app/sync/lanFront').middleware());
@@ -178,6 +181,7 @@ const runExpress = (conf = null) => {
 
     // ==== Start Listen ====
     const hostname = appConfig.host || 'localhost';
+    netstats.attach(server, {host: hostname, port});
     server.listen(port, hostname, async () => {
         if (hostname === 'localhost') {
             console.log(`Server started on  ${hostname} http://${hostname}:${port}`);