@alizadefaig/pos-server 1.2.26 → 1.2.28

package/app/sync/kv.js

@@ -0,0 +1,26 @@
+/**
+ * Мелкое состояние синка в таблице kv: сессия терминала, курсор зеркала, blob app.init, времена.
+ * Значение — JSON. Запись зовётся только внутри синхронного блока store.block(...), чтение —
+ * откуда угодно (незакоммиченная строка ядра в kv не попадает, ядро kv не пишет).
+ */
+const get = (store, key, fallback = null) => {
+    const row = store.get('SELECT value FROM kv WHERE key = ?', [key]);
+    if (!row || row.value === null || row.value === undefined) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(row.value);
+    } catch (e) {
+        return fallback;
+    }
+};
+
+const set = (store, key, value) => store.run(
+    `INSERT INTO kv (key, value, updated_at) VALUES (?, ?, datetime('now'))
+     ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`,
+    [key, JSON.stringify(value === undefined ? null : value)]
+);
+
+const del = (store, key) => store.run('DELETE FROM kv WHERE key = ?', [key]);
+
+module.exports = {get, set, del};

package/app/sync/lan.js

@@ -0,0 +1,139 @@
+const {timingSafeEqual} = require('node:crypto');
+const {isSyncEnabled, isLanFrontEnabled, lanKey, LAN_KEY_HEADER} = require('./config');
+const lanDevices = require('./lanDevices');
+
+/**
+ * Защита мастера в зале. Мастер слушает 0.0.0.0, чтобы до него дошли ведомые терминалы, —
+ * значит, до него дойдёт и любое устройство в той же Wi-Fi. Всё, что пришло не с этой же
+ * машины, обязано предъявить общий ключ зала (CAFEPOS_LAN_KEY).
+ *
+ * Работает только при включённом синке и заданном ключе: облачный Node (публичный, без этих
+ * переменных) и касса без офлайна ведут себя как раньше.
+ */
+const isLoopback = (address) => {
+    // Адреса нет (сокет уже закрыт, нестандартный транспорт) — считаем чужим: пропускать
+    // «неизвестно кого» без ключа нельзя.
+    if (!address) {
+        return false;
+    }
+    const value = String(address).replace(/^::ffff:/, '');
+    return value === '::1' || value === 'localhost' || value.startsWith('127.');
+};
+
+const keyMatches = (provided) => {
+    const expected = lanKey();
+    if (!expected || typeof provided !== 'string' || !provided) {
+        return false;
+    }
+    const a = Buffer.from(provided);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+};
+
+const guardActive = () => isSyncEnabled() && Boolean(lanKey());
+
+// Поиск мастера (discovery.js): ведомый ещё не знает, кто мастер, и не шлёт ключ на неизвестный
+// адрес. Ответ подписан ключом и сам его не раскрывает, поэтому путь открыт без ключа.
+// /local/lan — опрос телефона, ушедшего на мастера по LAN (пора ли назад в облако): режим и
+// доступность облака, ничего секретного.
+const isKeylessPath = (req) => req.method === 'GET' && (req.path === '/local/whoami' || req.path === '/local/lan');
+
+// Что телефону с токеном можно на мастере:
+// - API и пустой /init фронта;
+// - /tax — фискальный аппарат стоит в сети зала, а телефон на http-странице до него не дотянется
+//   сам. Мастер проксирует так же, как для своей страницы;
+// - printers.print — только сетевой принтер в частной сети (проверка в routes/desktop/api/printers.js).
+// Служебное (/local/session, /socket/request) и список принтеров самой кассы — только кассам зала
+// с ключом.
+const MASTER_ONLY_API = new Set(['/api/printers.get', '/api/printers.getusbprinters']);
+const isDevicePath = (req) => {
+    const p = req.path.toLowerCase();
+    return (p.startsWith('/api/') && !MASTER_ONLY_API.has(p))
+        || p === '/tax' || p.startsWith('/tax/')
+        || (req.method === 'GET' && p === '/init');
+};
+
+const session = () => require('./index').session();
+
+/**
+ * Телефон официанта, ушедший с облака на мастера (LAN-переход): ключа зала у него нет, есть
+ * его обычный токен. Мастер узнаёт токен по реестру устройств заведения (lanDevices).
+ */
+const deviceFromRequest = (req) => {
+    if (!isLanFrontEnabled() || !isDevicePath(req)) {
+        return null;
+    }
+    const result = lanDevices.verify({
+        authorization: req.get('authorization'),
+        terminalId: req.get('terminal-id'),
+        companyId: req.get('company-id'),
+        teamId: req.get('team-id'),
+    }, session());
+    return result.ok ? result.device : null;
+};
+
+/** Express-middleware: чужой адрес без ключа — 403. */
+const httpGuard = (req, res, next) => {
+    if (!guardActive() || isLoopback(req.socket && req.socket.remoteAddress) || isKeylessPath(req)) {
+        return next();
+    }
+    if (keyMatches(req.get(LAN_KEY_HEADER))) {
+        return next();
+    }
+    const device = deviceFromRequest(req);
+    if (device) {
+        req.lanDevice = device;
+        return next();
+    }
+    return res.status(403).json({success: false, message: 'Forbidden'});
+};
+
+const bearer = (token) => {
+    if (typeof token !== 'string' || !token) {
+        return null;
+    }
+    return /^Bearer\s/i.test(token) ? token : `Bearer ${token}`;
+};
+
+const first = (value) => (Array.isArray(value) ? value[0] : value);
+
+/** Телефон по токену в handshake: auth.token + auth.team_id, query.company_id + query.terminal_id. */
+const deviceFromHandshake = (handshake) => {
+    if (!isLanFrontEnabled()) {
+        return null;
+    }
+    const auth = handshake.auth || {};
+    const query = handshake.query || {};
+    const result = lanDevices.verify({
+        authorization: bearer(first(auth.token)),
+        terminalId: first(query.terminal_id),
+        companyId: first(query.company_id),
+        teamId: first(auth.team_id),
+    }, session());
+    return result.ok ? result.device : null;
+};
+
+/** socket.io-middleware (io.use): тот же ключ в handshake.auth.lan_key либо query.lan_key. */
+const socketGuard = (socket, next) => {
+    if (!guardActive() || isLoopback(socket.handshake && socket.handshake.address)) {
+        return next();
+    }
+    const handshake = socket.handshake || {};
+    const provided = (handshake.auth && handshake.auth.lan_key) || (handshake.query && handshake.query.lan_key);
+    if (keyMatches(provided)) {
+        return next();
+    }
+    const device = deviceFromHandshake(handshake);
+    if (device) {
+        socket.data.lanDevice = device;
+        return next();
+    }
+    // Токена нет в реестре — возможно, телефон вошёл минуту назад и мастер ещё не обновил
+    // список. 'unauthorized' фронт повторяет сам (через 15 с), 'Forbidden' — нет.
+    return next(new Error(isLanFrontEnabled() && handshake.auth && handshake.auth.token ? 'unauthorized' : 'Forbidden'));
+};
+
+/** Заголовки запроса ведомого к мастеру. */
+const lanHeaders = () => (lanKey() ? {[LAN_KEY_HEADER]: lanKey()} : {});
+
+module.exports = {httpGuard, socketGuard, lanHeaders, isLoopback, keyMatches};

package/app/sync/lanDevices.js

@@ -0,0 +1,177 @@
+const {createHash, timingSafeEqual} = require('node:crypto');
+const kv = require('./kv');
+const config = require('./config');
+
+/**
+ * Реестр устройств заведения для LAN-перехода (config.isLanFrontEnabled): телефон официанта,
+ * ушедший с облака на мастера, предъявляет свой обычный токен Sanctum, и мастер узнаёт его
+ * без облака.
+ *
+ * Облако (sync.lanDevices, LanHandoffService::devices) отдаёт sha256 токенов, привязанных к
+ * терминалам заведения, — ровно то, что Sanctum хранит в БД. Сам токен облако не знает, мастер
+ * тоже: он только сверяет хеш. Копия лежит в kv (lan_devices) и переживает перезапуск кассы —
+ * без интернета её взять неоткуда.
+ *
+ * Новый токен мастер узнаёт на следующем обновлении (LAN_DEVICES_MS, 60 с) и только пока есть
+ * облако: телефон, вошедший уже после обрыва, мастер не пустит.
+ */
+const KEY = 'lan_devices';
+
+const state = {
+    data: null,
+    tokens: new Map(),
+    at: null,
+    error: null,
+    lastTry: 0,
+};
+
+const nowIso = () => new Date().toISOString();
+
+const valid = (data) => Boolean(data)
+    && typeof data === 'object'
+    && typeof data.company_id === 'string'
+    && Array.isArray(data.tokens)
+    && data.terminals !== null
+    && typeof data.terminals === 'object';
+
+const apply = (data) => {
+    state.data = data;
+    state.tokens = new Map();
+    for (const token of data.tokens) {
+        if (token && token.id !== undefined && token.id !== null && typeof token.hash === 'string') {
+            state.tokens.set(String(token.id), token);
+        }
+    }
+};
+
+const clear = () => {
+    state.data = null;
+    state.tokens = new Map();
+};
+
+/** Копия из kv после перезапуска: без облака другой взять неоткуда. */
+const load = (store) => {
+    if (state.data || !store) {
+        return;
+    }
+    const saved = kv.get(store, KEY);
+    if (valid(saved)) {
+        apply(saved);
+        state.at = saved.fetched_at || null;
+    }
+};
+
+const due = () => Date.now() - state.lastTry >= config.lanFront().devices;
+
+/**
+ * Свежий список из облака. Облако недоступно — старый список остаётся (ради него всё и
+ * затевалось). 404/403 — раздача выключена или касса больше не мастер: старым токенам
+ * не верим, копию стираем.
+ */
+const refresh = async (cloud, store) => {
+    state.lastTry = Date.now();
+    let data;
+    try {
+        data = await cloud.call('sync.lanDevices', {});
+    } catch (e) {
+        if (e.name === 'CloudRequestError' && (e.status === 403 || e.status === 404)) {
+            clear();
+            state.at = null;
+            state.error = e.body && e.body.reason ? e.body.reason : `HTTP ${e.status}`;
+            await store.block((s) => kv.del(s, KEY));
+            return;
+        }
+        state.error = e.message;
+        throw e;
+    }
+    if (!valid(data)) {
+        state.error = 'invalid_response';
+        return;
+    }
+    const saved = {...data, fetched_at: nowIso()};
+    await store.block((s) => kv.set(s, KEY, saved));
+    apply(saved);
+    state.at = saved.fetched_at;
+    state.error = null;
+};
+
+const sameHex = (a, b) => {
+    if (typeof a !== 'string' || typeof b !== 'string' || a.length !== b.length) {
+        return false;
+    }
+    return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+};
+
+const header = (value) => (Array.isArray(value) ? value[0] : value) || null;
+
+/**
+ * Узнать устройство по токену и заголовкам контекста. Токен — формата Sanctum `{id}|{plain}`,
+ * проверяется так же, как в Laravel: sha256(plain) против хеша строки с этим id. Терминал,
+ * заведение и команда обязаны совпасть с токеном и с сессией мастера — чужое заведение по
+ * своему токену сюда не попадёт.
+ *
+ * @returns {{ok: true, device: object} | {ok: false, reason: string}}
+ */
+const verify = ({authorization, terminalId, companyId, teamId}, session) => {
+    if (!state.data) {
+        return {ok: false, reason: 'no_devices'};
+    }
+    const match = /^Bearer\s+(\d+)\|(\S+)$/i.exec(header(authorization) || '');
+    if (!match) {
+        return {ok: false, reason: 'no_token'};
+    }
+    const token = state.tokens.get(match[1]);
+    const hash = createHash('sha256').update(match[2]).digest('hex');
+    if (!token || !sameHex(hash, token.hash)) {
+        return {ok: false, reason: 'unknown_token'};
+    }
+    if (token.expires_at && !(Date.parse(token.expires_at) > Date.now())) {
+        return {ok: false, reason: 'expired'};
+    }
+    terminalId = header(terminalId);
+    companyId = header(companyId);
+    teamId = header(teamId);
+    if (!terminalId || token.terminal_id !== terminalId || !state.data.terminals[terminalId]) {
+        return {ok: false, reason: 'terminal_mismatch'};
+    }
+    if (!session || !companyId || companyId !== session.company_id || companyId !== state.data.company_id) {
+        return {ok: false, reason: 'company_mismatch'};
+    }
+    if (session.team_id && teamId !== session.team_id) {
+        return {ok: false, reason: 'team_mismatch'};
+    }
+    return {
+        ok: true,
+        device: {
+            token_id: String(token.id),
+            terminal_id: terminalId,
+            company_id: companyId,
+            team_id: teamId,
+        },
+    };
+};
+
+/** TerminalResource терминала заведения — для app.init телефона. */
+const terminal = (id) => (state.data && id && state.data.terminals[id]) || null;
+
+/** Смена личности кассы: список чужого заведения больше не годится. */
+const reset = async (store) => {
+    clear();
+    state.at = null;
+    state.error = null;
+    state.lastTry = 0;
+    if (store) {
+        await store.block((s) => kv.del(s, KEY));
+    }
+};
+
+const status = () => ({
+    at: state.at,
+    error: state.error,
+    company_id: state.data ? state.data.company_id : null,
+    generated_at: state.data ? state.data.generated_at || null : null,
+    tokens: state.tokens.size,
+    terminals: state.data ? Object.keys(state.data.terminals).length : 0,
+});
+
+module.exports = {load, due, refresh, verify, terminal, reset, status, _state: state};