cursorconnect 0.1.0 → 0.1.4

package/bridge-runtime/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@cursor-connect/bridge",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "dotenv": "^17.3.1",
+    "express": "^4.21.0",
+    "socket.io": "^4.8.0",
+    "socket.io-client": "^4.8.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}

package/bridge-runtime/selectors.json

@@ -0,0 +1,74 @@
+{
+  "chatContainer": {
+    "strategies": [
+      "div.composer-bar.editor",
+      "[class*='composer-bar']",
+      "#workbench\\.parts\\.auxiliarybar",
+      "[class*='composer-panel']"
+    ]
+  },
+  "chatInput": {
+    "strategies": [
+      ".ui-prompt-input-editor__input[contenteditable='true']",
+      ".composer-bar .ui-prompt-input-editor__input[contenteditable='true']",
+      "#workbench\\.parts\\.auxiliarybar [contenteditable='true']",
+      ".composer-bar [contenteditable='true']",
+      "[class*='agent-panel'] [contenteditable='true']",
+      "[contenteditable='true']"
+    ]
+  },
+  "submitButton": {
+    "strategies": [
+      "button.ui-prompt-input-submit-button[data-state=\"active\"]",
+      "button.ui-prompt-input-submit-button[aria-label=\"Send message\"]",
+      "button.ui-prompt-input-submit-button:not([data-state=\"stop\"])"
+    ]
+  },
+  "chatTabList": {
+    "strategies": [
+      ".agent-sidebar-cell",
+      ".glass-sidebar-agent-list-container li.ui-sidebar-menu-item > div.glass-sidebar-agent-menu-btn"
+    ]
+  },
+  "newChatButton": {
+    "strategies": [
+      "[data-command-id='composer.createNewComposerTab']",
+      "a.codicon-add-two",
+      "[aria-label*='New Chat']"
+    ]
+  },
+  "modeDropdown": {
+    "strategies": [".composer-unified-dropdown[data-mode]"]
+  },
+  "modelDropdown": {
+    "strategies": [".composer-unified-dropdown-model"]
+  },
+  "approveButton": {
+    "strategies": [
+      "button.ui-shell-tool-call__run-btn",
+      "button.ui-shell-tool-call__allowlist-button",
+      "button[aria-label*='Accept']",
+      "button[aria-label*='Approve']",
+      "button[aria-label*='Run']",
+      "button[aria-label*='Allow']"
+    ],
+    "textMatch": ["Accept", "Approve", "Run", "Allow", "Accept All"]
+  },
+  "rejectButton": {
+    "strategies": [
+      "button.ui-shell-tool-call__skip-btn",
+      "button[aria-label*='Reject']",
+      "button[aria-label*='Skip']",
+      "button[aria-label*='Deny']"
+    ],
+    "textMatch": ["Reject", "Deny", "Cancel", "Skip"]
+  },
+  "stopButton": {
+    "strategies": [
+      "button.ui-prompt-input-submit-button[data-state=\"stop\"]",
+      "button[aria-label=\"Stop generation\"]",
+      "button.ui-prompt-input-submit-button[aria-label=\"Stop generation\"]",
+      "button[data-state=\"stop\"]"
+    ]
+  }
+}

package/config.env.defaults

@@ -0,0 +1,3 @@
+# CursorConnect — встроенный relay (переопределение: ~/.cursorconnect/config.env)
+RELAY_URL=https://cc.fanpay.online
+RELAY_TOKEN=cursorconnect-test-relay-2026

package/dist/big-code.js

@@ -0,0 +1,25 @@
+/** 5×5 block digits for terminal pairing code. */
+const DIGITS = {
+    '0': ['█████', '█   █', '█   █', '█   █', '█████'],
+    '1': ['  █  ', ' ██  ', '  █  ', '  █  ', ' ███ '],
+    '2': ['█████', '    █', '█████', '█    ', '█████'],
+    '3': ['█████', '    █', '█████', '    █', '█████'],
+    '4': ['█   █', '█   █', '█████', '    █', '    █'],
+    '5': ['█████', '█    ', '█████', '    █', '█████'],
+    '6': ['█████', '█    ', '█████', '█   █', '█████'],
+    '7': ['█████', '    █', '   █ ', '  █  ', ' █   '],
+    '8': ['█████', '█   █', '█████', '█   █', '█████'],
+    '9': ['█████', '█   █', '█████', '    █', '█████'],
+};
+const GAP = '   ';
+export function renderBigCode(code) {
+    const digits = code.replace(/\D/g, '').slice(0, 6);
+    const rows = ['', '', '', '', ''];
+    for (const ch of digits) {
+        const art = DIGITS[ch] ?? DIGITS['8'];
+        for (let i = 0; i < 5; i++) {
+            rows[i] += art[i] + GAP;
+        }
+    }
+    return rows.map((row) => `  ${row.trimEnd()}`).join('\n');
+}

package/dist/bridge-dir.js

@@ -0,0 +1,82 @@
+import { copyFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { CURSORCONNECT_DIR } from './paths.js';
+import { loadInstallConfig } from './repo-root.js';
+export const USER_CONFIG_ENV = join(CURSORCONNECT_DIR, 'config.env');
+export function resolvePackageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), '..');
+}
+export function isValidBridgeDir(dir) {
+    return existsSync(join(dir, 'dist', 'index.js'));
+}
+function bundledBridgeDir() {
+    const dir = join(resolvePackageRoot(), 'bridge-runtime');
+    return isValidBridgeDir(dir) ? dir : null;
+}
+function devMonorepoBridge() {
+    const candidate = join(resolvePackageRoot(), '..', 'bridge');
+    return isValidBridgeDir(candidate) ? resolve(candidate) : null;
+}
+function findBridgeFromCwd() {
+    let dir = process.cwd();
+    for (let i = 0; i < 12; i++) {
+        const bridge = join(dir, 'bridge');
+        if (isValidBridgeDir(bridge))
+            return resolve(bridge);
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Каталог bridge для spawn (bundled npm, monorepo dev или legacy init). */
+export function resolveBridgeDir() {
+    const fromEnv = process.env.CURSORCONNECT_BRIDGE_DIR?.trim();
+    if (fromEnv && isValidBridgeDir(fromEnv))
+        return resolve(fromEnv);
+    const fromCwd = findBridgeFromCwd();
+    if (fromCwd)
+        return fromCwd;
+    const fromDev = devMonorepoBridge();
+    if (fromDev)
+        return fromDev;
+    const bundled = bundledBridgeDir();
+    if (bundled)
+        return bundled;
+    const legacy = loadInstallConfig();
+    if (legacy) {
+        const bridge = join(legacy.repoRoot, 'bridge');
+        if (isValidBridgeDir(bridge))
+            return bridge;
+    }
+    throw new Error('Не найден bridge.\n' +
+        '  npm install -g cursorconnect && cursorconnect start\n' +
+        '  (для разработки: клон репо + npm install в корне)');
+}
+export function ensureUserConfig() {
+    mkdirSync(CURSORCONNECT_DIR, { recursive: true, mode: 0o700 });
+    if (existsSync(USER_CONFIG_ENV))
+        return;
+    const devBridge = findBridgeFromCwd() ?? devMonorepoBridge();
+    const devEnv = devBridge ? join(devBridge, '.env') : '';
+    if (devEnv && existsSync(devEnv)) {
+        copyFileSync(devEnv, USER_CONFIG_ENV);
+        return;
+    }
+    const bundled = join(resolvePackageRoot(), 'config.env.defaults');
+    if (existsSync(bundled)) {
+        copyFileSync(bundled, USER_CONFIG_ENV);
+        return;
+    }
+    const template = join(resolvePackageRoot(), 'bridge-runtime', '.env.example');
+    if (existsSync(template)) {
+        copyFileSync(template, USER_CONFIG_ENV);
+        return;
+    }
+    const devTemplate = join(resolvePackageRoot(), '..', 'bridge', '.env.example');
+    if (existsSync(devTemplate)) {
+        copyFileSync(devTemplate, USER_CONFIG_ENV);
+    }
+}

package/dist/cli-version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+export const CLI_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version?.trim() || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();

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
+                ? 'Bridge не в этой комнате на 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: 'bridge.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: 'bridge.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 или bridge не отвечает — 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,36 +1,29 @@
 #!/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';
 import { printPairingToTerminal } from './print-pairing.js';
 import { BRIDGE_LOG_FILE } from './paths.js';
-import { configFilePath, isValidRepoRoot, resolveRepoRoot, 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 { ensureUserConfig, isValidBridgeDir, resolveBridgeDir, USER_CONFIG_ENV, } from './bridge-dir.js';
+import { configFilePath, saveInstallConfig } from './repo-root.js';
+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) {
-    const repoRoot = resolveRepoRoot();
-    const bridgeEnvPath = join(repoRoot, 'bridge', '.env');
-    const file = loadEnvFile(bridgeEnvPath);
-    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 в bridge/.env (см. bridge/.env.example)');
+    ensureUserConfig();
+    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,
@@ -38,41 +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 (Mac) ===');
-    if (restartCursor) {
-        console.log('Флаг: --restart-cursor (перезапуск без вопроса)');
+    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(`Machine: ${refreshed.machineLabel}`);
-    console.log(`Room:    ${refreshed.roomId}`);
-    console.log(`Relay:   ${relayUrl}`);
     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);
-    printPairingToTerminal(relayUrl, refreshed, {
+    // 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,
     });
 }
@@ -83,30 +84,31 @@ async function cmdStop() {
 async function cmdInit(pathArg) {
     const target = pathArg?.trim() || process.cwd();
     const abs = resolve(target);
-    if (!isValidRepoRoot(abs)) {
+    if (!isValidBridgeDir(join(abs, 'bridge'))) {
         console.error(`Папка не похожа на CursorConnect: ${abs}\n` +
-            'Нужен каталог с bridge/package.json (клон репозитория + npm install).');
+            'Нужен клон репозитория (bridge/).\n' +
+            'После npm install -g cursorconnect команда init не нужна.');
         process.exit(1);
     }
     saveInstallConfig(abs);
-    console.log(`Сохранено: ${configFilePath()}`);
+    console.log(`Сохранено (dev): ${configFilePath()}`);
     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();
-    let repoRoot = '';
-    try {
-        repoRoot = resolveRepoRoot();
-    }
-    catch {
-        /* optional */
-    }
-    const env = loadEnvFile(repoRoot ? join(repoRoot, 'bridge', '.env') : '');
-    const relayUrl = env.RELAY_URL ?? '';
+    ensureUserConfig();
+    const bridgeDotEnv = join(resolveBridgeDir(), '.env');
+    const { relayUrl } = resolveRelayConfig([bridgeDotEnv]);
     console.log('Bridge running:', isBridgeRunning());
     if (!identity) {
-        console.log('Identity не найден — запустите: npm run connect:start');
+        console.log('Identity не найден — запустите: cursorconnect start');
         return;
     }
     let connector = false;
@@ -130,18 +132,15 @@ async function cmdStatus() {
         catch {
             /* ignore */
         }
+        printPairingToTerminal(identity, { bridge: bridgeOk, cdp, connector });
     }
-    if (relayUrl) {
-        printPairingToTerminal(relayUrl, identity, {
+    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);
@@ -157,19 +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>
 
-  init [path]                  — путь к клону CursorConnect (~/.cursorconnect/config.json)
-  start [--restart-cursor|-r]  — bridge в фоне + QR/код
+  start              — CDP (авто-перезапуск Cursor) + bridge + код
+  start -r           — то же (явный перезапуск Cursor)
+  start --no-restart-cursor — не трогать Cursor (спросит y/n в TTY)
   stop                         — остановить bridge
-  status                       — код, QR, health
+  status                       — код и статус
+  diagnose                     — проверка relay / bridge / socket (без гаданий)
+  init [path]                  — только для разработки (клон репо)
 
-Глобально: npm install -g cursorconnect
-В репо:     npm run connect:start`);
+Установка (из любой папки):
+  npm install -g cursorconnect
+  cursorconnect start   # код pairing, relay уже в пакете`);
             process.exit(cmd === 'help' ? 0 : 1);
     }
 }