cursorconnect 0.1.2 → 0.1.4

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,39 +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 порт недоступен — bridge запустится, список чатов будет из архива JSONL.');
     }
-    console.log(`Компьютер: ${refreshed.machineLabel}`);
     if (isBridgeRunning()) {
-        console.log('Перезапуск bridge (новый код pairing)…');
+        console.log('Перезапуск bridge…');
         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);
+    // 2) Ждём, пока bridge реально подключится к workbench (health.cdp), не только :9222.
+    const health = await waitBridgeHealth(45_000, { requireCdp: cdpPortOk });
+    const connectorOk = await waitRelayConnector(relayUrl, 30_000);
+    const cdpReady = cdpPortOk && health.cdp;
+    if (cdpPortOk && !health.cdp) {
+        console.warn('[cursorconnect] Порт 9222 открыт, но bridge не подключился к Cursor (cdp:false). ' +
+            'Проверьте: cursorconnect status · tail -f ' +
+            BRIDGE_LOG_FILE);
+    }
     printPairingToTerminal(refreshed, {
         bridge: health.ok,
-        cdp: cdpOk && health.cdp,
+        cdp: cdpReady,
         connector: connectorOk,
     });
 }
@@ -102,11 +95,17 @@ 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 ?? '';
+    const bridgeDotEnv = join(resolveBridgeDir(), '.env');
+    const { relayUrl } = resolveRelayConfig([bridgeDotEnv]);
     console.log('Bridge running:', isBridgeRunning());
     if (!identity) {
         console.log('Identity не найден — запустите: cursorconnect start');
@@ -133,18 +132,15 @@ async function cmdStatus() {
         catch {
             /* ignore */
         }
+        printPairingToTerminal(identity, { bridge: bridgeOk, cdp, connector });
     }
-    if (relayUrl) {
+    else {
         printPairingToTerminal(identity, {
             bridge: bridgeOk,
             cdp,
-            connector,
+            connector: false,
         });
     }
-    else {
-        console.log('Room:', identity.roomId);
-        console.log('Код:', identity.pairingCode);
-    }
 }
 async function main() {
     const argv = process.argv.slice(2);
@@ -160,21 +156,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 в фоне + код для приложения
+  start              — CDP (авто-перезапуск Cursor) + bridge + код
+  start -r           — то же (явный перезапуск Cursor)
+  start --no-restart-cursor — не трогать Cursor (спросит y/n в TTY)
   stop                         — остановить bridge
   status                       — код и статус
+  diagnose                     — проверка relay / bridge / 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

@@ -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'], {
@@ -51,19 +65,35 @@ export function startBridge(env) {
 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 +176,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,10 @@
 import { randomBytes, randomUUID } from 'crypto';
+import { generatePairingCode } from './pairing-code.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,7 +32,7 @@ export function ensurePairingIdentity(machineLabel) {
         roomId: randomUUID(),
         clientToken: randomBytes(32).toString('hex'),
         machineLabel: machineLabel?.trim() || defaultMachineLabel(),
-        pairingCode: formatPairingCode(),
+        pairingCode: generatePairingCode(),
         pairingCodeExpiresAt: Date.now() + 10 * 60_000,
         createdAt: now,
         updatedAt: now,
@@ -47,7 +44,7 @@ export function refreshPairingCode(identity, machineLabel) {
     const next = {
         ...identity,
         machineLabel: machineLabel?.trim() || identity.machineLabel,
-        pairingCode: formatPairingCode(),
+        pairingCode: generatePairingCode(),
         pairingCodeExpiresAt: Date.now() + 10 * 60_000,
         updatedAt: new Date().toISOString(),
     };

package/dist/print-pairing.js

@@ -1,19 +1,18 @@
-import { renderBigCode } from './big-code.js';
 export function printPairingToTerminal(identity, status) {
     const expiresIn = Math.max(0, Math.floor((identity.pairingCodeExpiresAt - Date.now()) / 1000));
-    const ok = status.bridge && status.cdp && status.connector;
+    const ready = status.bridge && status.cdp && status.connector;
     const code = identity.pairingCode;
     console.log('\n────────────────────────────────────────');
-    console.log(`  ${identity.machineLabel}`);
+    console.log('  CursorConnect');
+    console.log(`  Компьютер: ${identity.machineLabel}`);
     console.log('');
     console.log('  Введите код в приложении CursorConnect:');
     console.log('');
-    console.log(renderBigCode(code));
+    console.log(`  ${code}`);
     console.log('');
-    console.log(`  Код: ${code.split('').join(' ')}`);
+    console.log('  Код одноразовый — после подключения снова: cursorconnect start');
     console.log(`  Действует ~${Math.max(1, Math.floor(expiresIn / 60))} мин`);
-    console.log('');
-    if (!ok) {
+    if (!ready) {
         const parts = [];
         if (!status.bridge)
             parts.push('bridge');
@@ -21,12 +20,15 @@ export function printPairingToTerminal(identity, status) {
             parts.push('Cursor');
         if (!status.connector)
             parts.push('сервер');
+        console.log('');
         console.log(`  Ожидание: ${parts.join(', ')}…`);
         console.log('  Подождите 10–20 с и снова: cursorconnect status');
     }
     else {
+        console.log('');
         console.log('  Готово — введите код на телефоне.');
     }
+    console.log('');
     console.log('────────────────────────────────────────');
     console.log('  Bridge в фоне · cursorconnect stop');
     console.log('  Консоль можно закрыть.\n');

package/dist/relay-config.js

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { resolvePackageRoot } from './bridge-dir.js';
+import { USER_CONFIG_ENV } from './bridge-dir.js';
+/** Shipped with npm package (generated at publish from bridge/.env). */
+export const BUNDLED_CONFIG_ENV = join(resolvePackageRoot(), 'config.env.defaults');
+/** Public production relay (same as app `extra.bridgeUrl`). */
+export const DEFAULT_RELAY_URL = 'https://cc.fanpay.online';
+export 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;
+}
+function pickNonEmpty(...values) {
+    for (const v of values) {
+        const t = v?.trim();
+        if (t)
+            return t;
+    }
+    return '';
+}
+/** Relay URL + connector token: bundled defaults → user config → bridge .env → process.env. */
+export function resolveRelayConfig(extraPaths = []) {
+    const layers = [];
+    if (existsSync(BUNDLED_CONFIG_ENV))
+        layers.push(loadEnvFile(BUNDLED_CONFIG_ENV));
+    for (const p of extraPaths) {
+        if (existsSync(p))
+            layers.push(loadEnvFile(p));
+    }
+    if (existsSync(USER_CONFIG_ENV))
+        layers.push(loadEnvFile(USER_CONFIG_ENV));
+    const merged = {};
+    for (const layer of layers)
+        Object.assign(merged, layer);
+    const relayUrl = pickNonEmpty(merged.RELAY_URL, process.env.RELAY_URL, DEFAULT_RELAY_URL);
+    const relayToken = pickNonEmpty(merged.RELAY_TOKEN, process.env.RELAY_TOKEN);
+    return { relayUrl, relayToken };
+}

package/dist/semver.js

@@ -0,0 +1,21 @@
+export function parseSemver(v) {
+    const m = v.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+export function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] !== pb[i])
+            return pa[i] < pb[i] ? -1 : 1;
+    }
+    return 0;
+}
+export function isVersionAtLeast(current, minimum) {
+    const c = compareSemver(current, minimum);
+    return c !== null && c >= 0;
+}

package/dist/version-check.js

@@ -0,0 +1,31 @@
+import { isVersionAtLeast } from './semver.js';
+import { CLI_VERSION } from './cli-version.js';
+export async function fetchRemoteVersionPolicy(relayUrl) {
+    const base = relayUrl.replace(/\/$/, '');
+    try {
+        const res = await fetch(`${base}/api/version-policy`, {
+            signal: AbortSignal.timeout(12_000),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+export function assertCliVersionAllowed(policy, current = CLI_VERSION) {
+    if (isVersionAtLeast(current, policy.minCliVersion))
+        return;
+    console.error(`[cursorconnect] Версия ${current} устарела (нужна ≥ ${policy.minCliVersion}).\n` +
+        `  ${policy.updateCliCommand}`);
+    process.exit(1);
+}
+export async function ensureCliVersionForRelay(relayUrl) {
+    const policy = await fetchRemoteVersionPolicy(relayUrl);
+    if (!policy?.minCliVersion) {
+        console.warn('[cursorconnect] Не удалось проверить версию на relay — продолжаем без проверки.');
+        return;
+    }
+    assertCliVersionAllowed(policy);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursorconnect",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "CLI: CursorConnect bridge + relay pairing — install once, run from anywhere",
   "license": "MIT",
   "type": "module",
@@ -10,6 +10,8 @@
   "files": [
     "dist/**/*.js",
     "bridge-runtime/**",
+    "config.env.defaults",
+    "version-policy.json",
     "README.md"
   ],
   "scripts": {
@@ -29,7 +31,9 @@
     "bridge",
     "relay"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "socket.io-client": "^4.8.0"
+  },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",

package/version-policy.json

@@ -0,0 +1,8 @@
+{
+  "minCliVersion": "0.1.4",
+  "minAppVersion": "0.2.2",
+  "latestCliVersion": "0.1.4",
+  "latestAppVersion": "0.2.2",
+  "updateCliCommand": "npm install -g cursorconnect@latest",
+  "updateAppHint": "Обновите CursorConnect в App Store / TestFlight до последней сборки."
+}