cursorconnect 0.1.2 → 0.1.5

package/dist/diagnose.js

@@ -0,0 +1,224 @@
+import { io } from 'socket.io-client';
+import { resolveRelayConfig, DEFAULT_RELAY_URL } from './relay-config.js';
+import { loadPairingIdentity } from './pairing-identity.js';
+function loadRelayUrl() {
+    return resolveRelayConfig().relayUrl || DEFAULT_RELAY_URL;
+}
+function socketProbe(relayUrl, auth, transports, expectIndex) {
+    return new Promise((resolve) => {
+        const socket = io(relayUrl, {
+            transports,
+            auth,
+            reconnection: false,
+            timeout: 12_000,
+        });
+        let indexRepos = null;
+        const transportLabel = transports.join('+');
+        const done = (ok, detail) => {
+            socket.disconnect();
+            resolve({ ok, detail });
+        };
+        socket.on('connect', () => {
+            if (!expectIndex) {
+                done(true, `connect id=${socket.id} transport=${socket.io.engine.transport.name}`);
+                return;
+            }
+            socket.emit('agents:refresh');
+        });
+        socket.on('agents:index', (idx) => {
+            indexRepos = idx?.repos?.length ?? 0;
+            done(true, `connect transport=${socket.io.engine.transport.name} agents:index repos=${indexRepos}`);
+        });
+        socket.on('connect_error', (err) => {
+            done(false, `${transportLabel}: ${err.message}`);
+        });
+        setTimeout(() => {
+            if (socket.connected && !expectIndex)
+                return;
+            if (socket.connected && expectIndex) {
+                done(false, `${transportLabel}: connect ok, agents:index timeout (wrong room?)`);
+                return;
+            }
+            done(false, `${transportLabel}: timeout`);
+        }, expectIndex ? 10_000 : 8_000);
+    });
+}
+function historyProbe(relayUrl, auth, agentId, title) {
+    return new Promise((resolve) => {
+        const socket = io(relayUrl, {
+            transports: ['websocket', 'polling'],
+            auth,
+            reconnection: false,
+            timeout: 15_000,
+        });
+        const t0 = Date.now();
+        const done = (ok, detail) => {
+            socket.disconnect();
+            resolve({ ok, detail });
+        };
+        socket.on('connect', () => {
+            socket.emit('agents:history', { agentId, title });
+        });
+        socket.on('agents:history', (h) => {
+            done(true, `${h.messages?.length ?? 0} msgs for ${h.agentId ?? agentId} in ${Date.now() - t0}ms`);
+        });
+        socket.on('connect_error', (err) => done(false, err.message));
+        setTimeout(() => done(false, 'agents:history timeout (20s)'), 20_000);
+    });
+}
+export async function runDiagnose() {
+    const identity = loadPairingIdentity();
+    const relayUrl = (loadRelayUrl() || 'https://cc.fanpay.online').replace(/\/$/, '');
+    const checks = [];
+    if (!identity) {
+        return {
+            at: new Date().toISOString(),
+            relayUrl,
+            roomId: '',
+            checks: [
+                {
+                    id: 'identity',
+                    ok: false,
+                    detail: 'Нет ~/.cursorconnect/identity.json',
+                    hint: 'cursorconnect start',
+                },
+            ],
+        };
+    }
+    const roomId = identity.roomId;
+    const token = identity.clientToken;
+    // 1 Relay HTTP
+    try {
+        const res = await fetch(`${relayUrl}/health`);
+        const j = (await res.json());
+        checks.push({
+            id: 'relay.health',
+            ok: Boolean(j.ok),
+            detail: `ok=${j.ok} connector=${j.connector} peers=${JSON.stringify(j.peers)}`,
+            hint: j.connector ? undefined : 'cursorconnect start на Mac',
+        });
+    }
+    catch (e) {
+        checks.push({
+            id: 'relay.health',
+            ok: false,
+            detail: e.message,
+            hint: 'Проверьте RELAY_URL и интернет',
+        });
+    }
+    // 2 Room diagnostics API
+    try {
+        const q = new URLSearchParams({ roomId, token });
+        const res = await fetch(`${relayUrl}/api/diagnostics?${q}`);
+        const j = (await res.json());
+        const ok = Boolean(j.ok);
+        checks.push({
+            id: 'relay.room',
+            ok: ok && Boolean(j.connectorInRoom) && Boolean(j.tokenRegistered),
+            detail: JSON.stringify(j),
+            hint: !j.connectorInRoom
+                ? 'Cursor Connect не в этой комнате на relay'
+                : !j.tokenRegistered
+                    ? 'Токен не зарегистрирован — перезапустите cursorconnect start'
+                    : !j.tokenAccepted
+                        ? 'Токен не в whitelist комнаты'
+                        : undefined,
+        });
+    }
+    catch (e) {
+        checks.push({
+            id: 'relay.room',
+            ok: false,
+            detail: e.message,
+            hint: 'Обновите relay: npm run deploy:relay',
+        });
+    }
+    // 3 Local bridge
+    try {
+        const res = await fetch('http://127.0.0.1:3847/health');
+        const j = (await res.json());
+        checks.push({
+            id: 'cursor-connect.local',
+            ok: Boolean(j.ok),
+            detail: `ok=${j.ok} cdp=${j.cdp}`,
+            hint: j.cdp ? undefined : 'Cursor с --remote-debugging-port=9222',
+        });
+    }
+    catch (e) {
+        checks.push({
+            id: 'cursor-connect.local',
+            ok: false,
+            detail: e.message,
+            hint: 'cursorconnect start',
+        });
+    }
+    // 4 Pairing code (не вызываем POST /api/pair — код одноразовый)
+    const code = identity.pairingCode?.replace(/[^A-Z0-9]/gi, '').toUpperCase() ?? '';
+    const codeValid = code.length === 6 && identity.pairingCodeExpiresAt > Date.now();
+    if (codeValid) {
+        const secLeft = Math.max(0, Math.floor((identity.pairingCodeExpiresAt - Date.now()) / 1000));
+        checks.push({
+            id: 'pair.code',
+            ok: true,
+            detail: `active ${code} (~${secLeft}s)`,
+            hint: 'Введите в app до истечения; повторный start — новый код',
+        });
+    }
+    else {
+        checks.push({
+            id: 'pair.code',
+            ok: false,
+            detail: 'Код истёк или отсутствует',
+            hint: 'cursorconnect start',
+        });
+    }
+    const auth = { token, roomId };
+    const ws = await socketProbe(relayUrl, auth, ['websocket'], true);
+    checks.push({
+        id: 'socket.ws+room',
+        ok: ws.ok,
+        detail: ws.detail,
+        hint: ws.ok ? undefined : 'Телефон: нужен polling+websocket в app',
+    });
+    const poll = await socketProbe(relayUrl, auth, ['polling'], true);
+    checks.push({
+        id: 'socket.poll+room',
+        ok: poll.ok,
+        detail: poll.detail,
+        hint: poll.ok ? undefined : 'Relay/nginx блокирует long-polling?',
+    });
+    const wrongRoom = await socketProbe(relayUrl, { token, roomId: 'default' }, ['websocket', 'polling'], true);
+    checks.push({
+        id: 'socket.wrong-room',
+        ok: !wrongRoom.ok,
+        detail: wrongRoom.detail,
+        hint: wrongRoom.ok
+            ? 'App подключается к room=default вместо вашего roomId'
+            : undefined,
+    });
+    const history = await historyProbe(relayUrl, auth, 'sidebar-0', 'Git repository creation and project deployment');
+    checks.push({
+        id: 'socket.history',
+        ok: history.ok,
+        detail: history.detail,
+        hint: history.ok ? undefined : 'connectorInRoom false или Cursor Connect не отвечает — cursorconnect start',
+    });
+    return { at: new Date().toISOString(), relayUrl, roomId, checks };
+}
+export function formatDiagnoseReport(report) {
+    const lines = [
+        `CursorConnect diagnose @ ${report.at}`,
+        `relay=${report.relayUrl}`,
+        `room=${report.roomId}`,
+        '',
+    ];
+    for (const c of report.checks) {
+        lines.push(`${c.ok ? 'PASS' : 'FAIL'}  ${c.id}`);
+        lines.push(`      ${c.detail}`);
+        if (c.hint)
+            lines.push(`      → ${c.hint}`);
+    }
+    const failed = report.checks.filter((c) => !c.ok).length;
+    lines.push('', failed === 0 ? 'Итог: все проверки пройдены' : `Итог: ${failed} проблем(а)`);
+    return lines.join('\n');
+}

package/dist/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { ensurePairingIdentity, loadPairingIdentity, refreshPairingCode, } from './pairing-identity.js';
 import { ensureCursorCdp, isBridgeRunning, startBridge, stopBridge, waitBridgeHealth, waitRelayConnector, } from './launch.js';
@@ -7,40 +6,24 @@ import { printPairingToTerminal } from './print-pairing.js';
 import { BRIDGE_LOG_FILE } from './paths.js';
 import { ensureUserConfig, isValidBridgeDir, resolveBridgeDir, USER_CONFIG_ENV, } from './bridge-dir.js';
 import { configFilePath, saveInstallConfig } from './repo-root.js';
-function loadEnvFile(path) {
-    if (!existsSync(path))
-        return {};
-    const out = {};
-    for (const line of readFileSync(path, 'utf-8').split('\n')) {
-        const t = line.trim();
-        if (!t || t.startsWith('#'))
-            continue;
-        const i = t.indexOf('=');
-        if (i < 1)
-            continue;
-        out[t.slice(0, i).trim()] = t.slice(i + 1).trim();
-    }
-    return out;
-}
+import { formatDiagnoseReport, runDiagnose } from './diagnose.js';
+import { loadEnvFile, resolveRelayConfig } from './relay-config.js';
+import { ensureCliVersionForRelay } from './version-check.js';
+import { CLI_VERSION } from './cli-version.js';
 function bridgeEnv(identity) {
     ensureUserConfig();
-    const paths = [
-        USER_CONFIG_ENV,
-        join(resolveBridgeDir(), '.env'),
-    ];
-    let file = {};
-    for (const p of paths) {
-        if (existsSync(p)) {
-            file = { ...file, ...loadEnvFile(p) };
-        }
-    }
-    const relayUrl = file.RELAY_URL ?? process.env.RELAY_URL ?? '';
-    const relayToken = file.RELAY_TOKEN ?? process.env.RELAY_TOKEN ?? '';
-    if (!relayUrl || !relayToken) {
-        console.error(`Нужны RELAY_URL и RELAY_TOKEN в ${USER_CONFIG_ENV}\n` +
-            '(создаётся при установке; отредактируйте и снова: cursorconnect start)');
+    const bridgeDotEnv = join(resolveBridgeDir(), '.env');
+    const { relayUrl, relayToken } = resolveRelayConfig([bridgeDotEnv]);
+    if (!relayToken) {
+        console.error('[cursorconnect] Не найден RELAY_TOKEN (встроенный конфиг пакета повреждён).\n' +
+            `  Переустановите: npm install -g cursorconnect\n` +
+            `  Или укажите RELAY_TOKEN в ${USER_CONFIG_ENV} (свой relay).`);
         process.exit(1);
     }
+    const file = {
+        ...loadEnvFile(bridgeDotEnv),
+        ...loadEnvFile(USER_CONFIG_ENV),
+    };
     return {
         RELAY_URL: relayUrl,
         RELAY_TOKEN: relayToken,
@@ -48,45 +31,49 @@ function bridgeEnv(identity) {
         SERVER_HOST: '127.0.0.1',
         SERVER_PORT: '3847',
         CDP_URL: file.CDP_URL ?? 'http://127.0.0.1:9222',
+        CURSORCONNECT_CLI_VERSION: CLI_VERSION,
     };
 }
 function startFlags(argv) {
     return {
         restartCursor: argv.includes('--restart-cursor') || argv.includes('-r'),
+        noRestartCursor: argv.includes('--no-restart-cursor'),
     };
 }
 async function cmdStart(argv) {
-    const { restartCursor } = startFlags(argv);
+    const { restartCursor, noRestartCursor } = startFlags(argv);
     const identity = ensurePairingIdentity();
     const refreshed = refreshPairingCode(identity);
     const env = bridgeEnv(refreshed);
     const relayUrl = env.RELAY_URL;
-    console.log('CursorConnect');
-    if (restartCursor) {
-        console.log('Перезапуск Cursor с CDP…');
+    await ensureCliVersionForRelay(relayUrl);
+    // 1) Сначала CDP (порт 9222), иначе bridge стартует без сайдбара Cursor.
+    const cdpPortOk = await ensureCursorCdp({
+        cdpUrl: env.CDP_URL,
+        restartCursor,
+        noRestartCursor,
+    });
+    if (!cdpPortOk) {
+        console.warn('[cursorconnect] CDP порт недоступен — Cursor Connect запустится, список чатов будет из архива JSONL.');
     }
-    console.log(`Компьютер: ${refreshed.machineLabel}`);
     if (isBridgeRunning()) {
-        console.log('Перезапуск bridge (новый код pairing)…');
+        console.error('[cursorconnect] Перезапуск Cursor Connect…');
         stopBridge();
     }
     startBridge(env);
-    console.log(`Bridge в фоне → ${BRIDGE_LOG_FILE}`);
-    const cdpOk = await ensureCursorCdp({
-        cdpUrl: env.CDP_URL,
-        restartCursor,
-    });
-    const health = await waitBridgeHealth(25_000);
-    const connectorOk = await waitRelayConnector(relayUrl, 25_000);
-    printPairingToTerminal(refreshed, {
-        bridge: health.ok,
-        cdp: cdpOk && health.cdp,
-        connector: connectorOk,
-    });
+    let health = await waitBridgeHealth(12_000, { requireCdp: false });
+    if (health.ok && cdpPortOk && !health.cdp) {
+        health = await waitBridgeHealth(15_000, { requireCdp: true });
+    }
+    await waitRelayConnector(relayUrl, 12_000);
+    if (cdpPortOk && health.ok && !health.cdp) {
+        console.error(`[cursorconnect] CDP не подключён (cdp:false) · лог: ${BRIDGE_LOG_FILE}`);
+    }
+    printPairingToTerminal(refreshed);
 }
 async function cmdStop() {
     stopBridge();
-    console.log('Bridge остановлен');
+    console.log('Cursor Connect остановлен');
 }
 async function cmdInit(pathArg) {
     const target = pathArg?.trim() || process.cwd();
@@ -102,49 +89,21 @@ async function cmdInit(pathArg) {
     console.log(`repoRoot: ${abs}`);
     console.log('\nДальше: cursorconnect start');
 }
+async function cmdDiagnose() {
+    const report = await runDiagnose();
+    console.log(formatDiagnoseReport(report));
+    const failed = report.checks.some((c) => !c.ok);
+    process.exit(failed ? 1 : 0);
+}
 async function cmdStatus() {
     const identity = loadPairingIdentity();
     ensureUserConfig();
-    const env = loadEnvFile(USER_CONFIG_ENV);
-    const relayUrl = env.RELAY_URL ?? process.env.RELAY_URL ?? '';
-    console.log('Bridge running:', isBridgeRunning());
     if (!identity) {
-        console.log('Identity не найден — запустите: cursorconnect start');
-        return;
-    }
-    let connector = false;
-    let cdp = false;
-    let bridgeOk = false;
-    try {
-        const h = await fetch('http://127.0.0.1:3847/health');
-        const j = (await h.json());
-        bridgeOk = Boolean(j.ok);
-        cdp = Boolean(j.cdp);
-    }
-    catch {
-        /* offline */
-    }
-    if (relayUrl) {
-        try {
-            const res = await fetch(`${relayUrl.replace(/\/$/, '')}/health`);
-            const j = (await res.json());
-            connector = Boolean(j.connector);
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    if (relayUrl) {
-        printPairingToTerminal(identity, {
-            bridge: bridgeOk,
-            cdp,
-            connector,
-        });
-    }
-    else {
-        console.log('Room:', identity.roomId);
-        console.log('Код:', identity.pairingCode);
+        console.error('Identity не найден — запустите: cursorconnect start');
+        process.exit(1);
     }
+    console.error(`[cursorconnect] Cursor Connect работает: ${isBridgeRunning()}`);
+    printPairingToTerminal(identity);
 }
 async function main() {
     const argv = process.argv.slice(2);
@@ -160,21 +119,26 @@ async function main() {
         case 'status':
             await cmdStatus();
             break;
+        case 'diagnose':
+            await cmdDiagnose();
+            break;
         case 'init':
             await cmdInit(rest[0]);
             break;
         default:
             console.log(`Usage: cursorconnect <command>
 
-  start [--restart-cursor|-r]  — bridge в фоне + код для приложения
-  stop                         — остановить bridge
+  start              — CDP (авто-перезапуск Cursor) + Cursor Connect + код
+  start -r           — то же (явный перезапуск Cursor)
+  start --no-restart-cursor — не трогать Cursor (спросит y/n в TTY)
+  stop                         — остановить Cursor Connect
   status                       — код и статус
+  diagnose                     — проверка relay / Cursor Connect / socket (без гаданий)
   init [path]                  — только для разработки (клон репо)
 
 Установка (из любой папки):
   npm install -g cursorconnect
-  # один раз: ~/.cursorconnect/config.env → RELAY_URL и RELAY_TOKEN
-  cursorconnect start`);
+  cursorconnect start   # код pairing, relay уже в пакете`);
             process.exit(cmd === 'help' ? 0 : 1);
     }
 }

package/dist/launch.js

@@ -1,6 +1,6 @@
 import { execSync, spawn, spawnSync } from 'child_process';
 import { askYesNo } from './ask.js';
-import { existsSync, openSync, readFileSync, writeFileSync } from 'fs';
+import { closeSync, existsSync, openSync, readFileSync, writeFileSync } from 'fs';
 import { BRIDGE_LOG_FILE, BRIDGE_PID_FILE } from './paths.js';
 import { resolveBridgeDir } from './bridge-dir.js';
 export function isBridgeRunning() {
@@ -34,8 +34,22 @@ export function stopBridge() {
         /* ignore */
     }
 }
+function killProcessesOnBridgePort() {
+    try {
+        execSync('lsof -t -i:3847 2>/dev/null | xargs kill -TERM 2>/dev/null', {
+            stdio: 'ignore',
+            shell: '/bin/bash',
+        });
+        /* give old bridge time to exit */
+        execSync('sleep 0.5', { stdio: 'ignore', shell: '/bin/bash' });
+    }
+    catch {
+        /* port free */
+    }
+}
 export function startBridge(env) {
     stopBridge();
+    killProcessesOnBridgePort();
     const bridgeDir = resolveBridgeDir();
     const logFd = openLogAppend();
     const child = spawn('node', ['dist/index.js'], {
@@ -45,25 +59,47 @@ export function startBridge(env) {
         stdio: ['ignore', logFd, logFd],
     });
     child.unref();
+    try {
+        closeSync(logFd);
+    }
+    catch {
+        /* ignore */
+    }
     writeFileSync(BRIDGE_PID_FILE, String(child.pid));
     return child;
 }
 function openLogAppend() {
     return openSync(BRIDGE_LOG_FILE, 'a');
 }
-export async function waitBridgeHealth(maxMs = 30_000) {
+export async function waitBridgeHealth(maxMs = 30_000, opts) {
+    const requireCdp = opts?.requireCdp === true;
     const deadline = Date.now() + maxMs;
     while (Date.now() < deadline) {
         try {
             const res = await fetch('http://127.0.0.1:3847/health');
-            if (res.ok)
-                return (await res.json());
+            if (res.ok) {
+                const j = (await res.json());
+                const ok = Boolean(j.ok);
+                const cdp = Boolean(j.cdp);
+                if (ok && (!requireCdp || cdp))
+                    return { ok, cdp };
+            }
         }
         catch {
             /* retry */
         }
         await sleep(500);
     }
+    try {
+        const res = await fetch('http://127.0.0.1:3847/health');
+        if (res.ok) {
+            const j = (await res.json());
+            return { ok: Boolean(j.ok), cdp: Boolean(j.cdp) };
+        }
+    }
+    catch {
+        /* ignore */
+    }
     return { ok: false, cdp: false };
 }
 export async function waitRelayConnector(relayUrl, maxMs = 45_000) {
@@ -146,29 +182,31 @@ export async function ensureCursorCdp(opts = {}) {
     if (!running) {
         console.log('[cursorconnect] Cursor не запущен — старт с --remote-debugging-port=9222…');
         launchCursorWithCdp();
-        return waitCdp(cdpUrl, 50);
+        if (await waitCdp(cdpUrl, 50))
+            return true;
+        printManualCdpInstructions();
+        return false;
     }
-    // Cursor запущен, CDP недоступен
-    let shouldRestart = Boolean(opts.restartCursor);
+    // Cursor запущен, порт 9222 не отвечает — обычный запуск без --remote-debugging-port
+    let shouldRestart = opts.noRestartCursor !== true;
     if (!shouldRestart) {
-        if (!process.stdin.isTTY) {
-            console.warn('[cursorconnect] Cursor без CDP (нет интерактивного терминала).');
-            printManualCdpInstructions();
-            return false;
+        shouldRestart = Boolean(opts.restartCursor);
+        if (!shouldRestart && process.stdin.isTTY) {
+            shouldRestart = await askYesNo('Cursor без CDP. Перезапустить с --remote-debugging-port=9222? (y/n): ');
         }
-        shouldRestart = await askYesNo('Cursor запущен без CDP. Перезапустить с --remote-debugging-port=9222? (y/n): ');
     }
     if (!shouldRestart) {
+        console.warn('[cursorconnect] Cursor без CDP — список чатов будет только из JSONL.');
         printManualCdpInstructions();
         return false;
     }
+    console.log('[cursorconnect] Cursor без CDP — перезапуск с --remote-debugging-port=9222…');
     const quitOk = await quitCursor();
     if (!quitOk) {
-        console.warn('[cursorconnect] Не удалось закрыть Cursor.');
+        console.warn('[cursorconnect] Не удалось закрыть Cursor (Cmd+Q вручную).');
         printManualCdpInstructions();
         return false;
     }
-    console.log('[cursorconnect] Запуск Cursor с --remote-debugging-port=9222…');
     launchCursorWithCdp();
     if (await waitCdp(cdpUrl, 50))
         return true;

package/dist/pairing-code.js

@@ -0,0 +1,18 @@
+import { randomBytes } from 'crypto';
+export const PAIRING_CODE_LENGTH = 6;
+/** Latin letters + digits (ASCII), uppercase in storage. */
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+export function generatePairingCode() {
+    const bytes = randomBytes(PAIRING_CODE_LENGTH);
+    let out = '';
+    for (let i = 0; i < PAIRING_CODE_LENGTH; i++) {
+        out += ALPHABET[bytes[i] % ALPHABET.length];
+    }
+    return out;
+}
+export function normalizePairingCode(raw) {
+    const code = raw.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+    if (code.length !== PAIRING_CODE_LENGTH)
+        return null;
+    return code;
+}

package/dist/pairing-identity.js

@@ -1,13 +1,11 @@
 import { randomBytes, randomUUID } from 'crypto';
+import { generatePairingCode } from './pairing-code.js';
+import { PAIRING_CODE_TTL_MS } from './pairing-ttl.js';
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { homedir, hostname } from 'os';
 import { join } from 'path';
 const DIR = join(homedir(), '.cursorconnect');
 const FILE = join(DIR, 'identity.json');
-function formatPairingCode() {
-    const n = randomBytes(3).readUIntBE(0, 3) % 1_000_000;
-    return String(n).padStart(6, '0');
-}
 export function pairingIdentityPath() {
     return FILE;
 }
@@ -35,8 +33,8 @@ export function ensurePairingIdentity(machineLabel) {
         roomId: randomUUID(),
         clientToken: randomBytes(32).toString('hex'),
         machineLabel: machineLabel?.trim() || defaultMachineLabel(),
-        pairingCode: formatPairingCode(),
-        pairingCodeExpiresAt: Date.now() + 10 * 60_000,
+        pairingCode: generatePairingCode(),
+        pairingCodeExpiresAt: Date.now() + PAIRING_CODE_TTL_MS,
         createdAt: now,
         updatedAt: now,
     };
@@ -47,8 +45,8 @@ export function refreshPairingCode(identity, machineLabel) {
     const next = {
         ...identity,
         machineLabel: machineLabel?.trim() || identity.machineLabel,
-        pairingCode: formatPairingCode(),
-        pairingCodeExpiresAt: Date.now() + 10 * 60_000,
+        pairingCode: generatePairingCode(),
+        pairingCodeExpiresAt: Date.now() + PAIRING_CODE_TTL_MS,
         updatedAt: new Date().toISOString(),
     };
     savePairingIdentity(next);

package/dist/pairing-ttl.js

@@ -0,0 +1,3 @@
+/** Срок жизни pairing-кода (Mac ↔ relay). */
+export const PAIRING_CODE_TTL_MS = 10 * 60_000;
+export const PAIRING_CODE_TTL_MINUTES = 10;