cursorconnect 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# cursorconnect
+
+CLI для Mac: bridge в фоне, pairing (QR + код), Cursor с CDP.
+
+## Установка (пользователи)
+
+**Из npm** (после publish):
+
+```bash
+npm install -g cursorconnect
+```
+
+**Из репозитория** (без npm):
+
+```bash
+cd CursorConnect && npm install
+npm run install:cli
+```
+
+`install:cli` собирает пакет и ставит глобально `cursorconnect`, вызывает `init` для текущего репо.
+
+В `bridge/.env` задайте `RELAY_URL` и `RELAY_TOKEN`.
+
+## Команды
+
+```bash
+cursorconnect start              # bridge + QR в терминале
+cursorconnect start -r           # перезапуск Cursor с CDP без вопроса
+cursorconnect status
+cursorconnect stop
+cursorconnect init /path/to/CursorConnect
+```
+
+## Публикация в npm (maintainers)
+
+Из корня монорепо:
+
+```bash
+cd connect
+npm run build
+npm publish --access public
+```
+
+Пакет в registry: [`cursorconnect`](https://www.npmjs.com/package/cursorconnect) (имя в `package.json`).
+
+Перед первой публикацией: аккаунт npm, `npm login`, уникальное имя `cursorconnect` (или `@scope/cursorconnect` → `npm install @scope/cursorconnect`).

package/dist/ask.js

@@ -0,0 +1,17 @@
+import * as readline from 'readline/promises';
+/** y/yes/д/да → true; пустой ввод и остальное → false */
+export async function askYesNo(prompt) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = (await rl.question(prompt)).trim().toLowerCase();
+        return answer === 'y' || answer === 'yes' || answer === 'д' || answer === 'да';
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/index.js

@@ -0,0 +1,179 @@
+#!/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;
+}
+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)');
+        process.exit(1);
+    }
+    return {
+        RELAY_URL: relayUrl,
+        RELAY_TOKEN: relayToken,
+        RELAY_ROOM_ID: identity.roomId,
+        SERVER_HOST: '127.0.0.1',
+        SERVER_PORT: '3847',
+        CDP_URL: file.CDP_URL ?? 'http://127.0.0.1:9222',
+    };
+}
+function startFlags(argv) {
+    return {
+        restartCursor: argv.includes('--restart-cursor') || argv.includes('-r'),
+    };
+}
+async function cmdStart(argv) {
+    const { restartCursor } = 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 (перезапуск без вопроса)');
+    }
+    console.log(`Machine: ${refreshed.machineLabel}`);
+    console.log(`Room:    ${refreshed.roomId}`);
+    console.log(`Relay:   ${relayUrl}`);
+    if (isBridgeRunning()) {
+        console.log('Перезапуск bridge (новый код pairing)…');
+        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, {
+        bridge: health.ok,
+        cdp: cdpOk && health.cdp,
+        connector: connectorOk,
+    });
+}
+async function cmdStop() {
+    stopBridge();
+    console.log('Bridge остановлен');
+}
+async function cmdInit(pathArg) {
+    const target = pathArg?.trim() || process.cwd();
+    const abs = resolve(target);
+    if (!isValidRepoRoot(abs)) {
+        console.error(`Папка не похожа на CursorConnect: ${abs}\n` +
+            'Нужен каталог с bridge/package.json (клон репозитория + npm install).');
+        process.exit(1);
+    }
+    saveInstallConfig(abs);
+    console.log(`Сохранено: ${configFilePath()}`);
+    console.log(`repoRoot: ${abs}`);
+    console.log('\nДальше: cursorconnect start');
+}
+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 ?? '';
+    console.log('Bridge running:', isBridgeRunning());
+    if (!identity) {
+        console.log('Identity не найден — запустите: npm run connect: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(relayUrl, identity, {
+            bridge: bridgeOk,
+            cdp,
+            connector,
+        });
+    }
+    else {
+        console.log('Room:', identity.roomId);
+        console.log('Код:', identity.pairingCode);
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const cmd = argv[0] ?? 'start';
+    const rest = argv.slice(1);
+    switch (cmd) {
+        case 'start':
+            await cmdStart(rest);
+            break;
+        case 'stop':
+            await cmdStop();
+            break;
+        case 'status':
+            await cmdStatus();
+            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/код
+  stop                         — остановить bridge
+  status                       — код, QR, health
+
+Глобально: npm install -g cursorconnect
+В репо:     npm run connect:start`);
+            process.exit(cmd === 'help' ? 0 : 1);
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/launch.js

@@ -0,0 +1,188 @@
+import { execSync, spawn, spawnSync } from 'child_process';
+import { askYesNo } from './ask.js';
+import { existsSync, openSync, readFileSync, writeFileSync } from 'fs';
+import { BRIDGE_LOG_FILE, BRIDGE_PID_FILE } from './paths.js';
+import { resolveRepoRoot } from './repo-root.js';
+export function isBridgeRunning() {
+    if (!existsSync(BRIDGE_PID_FILE))
+        return false;
+    const pid = parseInt(readFileSync(BRIDGE_PID_FILE, 'utf-8').trim(), 10);
+    if (!Number.isFinite(pid))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function stopBridge() {
+    if (!existsSync(BRIDGE_PID_FILE))
+        return;
+    const pid = parseInt(readFileSync(BRIDGE_PID_FILE, 'utf-8').trim(), 10);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        /* already dead */
+    }
+    try {
+        writeFileSync(BRIDGE_PID_FILE, '');
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function startBridge(env) {
+    stopBridge();
+    const logFd = openLogAppend();
+    const child = spawn('npm', ['run', 'start', '-w', 'bridge'], {
+        cwd: resolveRepoRoot(),
+        env: { ...process.env, ...env },
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+    });
+    child.unref();
+    writeFileSync(BRIDGE_PID_FILE, String(child.pid));
+    return child;
+}
+function openLogAppend() {
+    return openSync(BRIDGE_LOG_FILE, 'a');
+}
+export async function waitBridgeHealth(maxMs = 30_000) {
+    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());
+        }
+        catch {
+            /* retry */
+        }
+        await sleep(500);
+    }
+    return { ok: false, cdp: false };
+}
+export async function waitRelayConnector(relayUrl, maxMs = 45_000) {
+    const base = relayUrl.replace(/\/$/, '');
+    const deadline = Date.now() + maxMs;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${base}/health`);
+            if (res.ok) {
+                const h = (await res.json());
+                if (h.connector)
+                    return true;
+            }
+        }
+        catch {
+            /* retry */
+        }
+        await sleep(800);
+    }
+    return false;
+}
+export function isCursorRunning() {
+    try {
+        execSync('pgrep -x Cursor', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function quitCursor(maxWaitMs = 20_000) {
+    if (!isCursorRunning())
+        return true;
+    console.log('[cursorconnect] Закрываю Cursor…');
+    spawnSync('osascript', ['-e', 'tell application "Cursor" to quit'], {
+        stdio: 'ignore',
+    });
+    const deadline = Date.now() + maxWaitMs;
+    while (Date.now() < deadline) {
+        await sleep(400);
+        if (!isCursorRunning())
+            return true;
+    }
+    console.log('[cursorconnect] Принудительное завершение Cursor…');
+    try {
+        spawnSync('killall', ['Cursor'], { stdio: 'ignore' });
+    }
+    catch {
+        /* ignore */
+    }
+    await sleep(800);
+    return !isCursorRunning();
+}
+const CDP_LAUNCH_CMD = 'open -a Cursor --args --remote-debugging-port=9222';
+export function printManualCdpInstructions() {
+    console.log('\n[cursorconnect] Запустите Cursor с CDP вручную:');
+    console.log(`  ${CDP_LAUNCH_CMD}`);
+    console.log('  (сначала Cmd+Q, если Cursor уже открыт)\n');
+}
+export function launchCursorWithCdp() {
+    spawn('open', ['-a', 'Cursor', '--args', '--remote-debugging-port=9222'], {
+        detached: true,
+        stdio: 'ignore',
+    }).unref();
+}
+async function waitCdp(cdpUrl, attempts = 40) {
+    for (let i = 0; i < attempts; i++) {
+        if (await cdpReachable(cdpUrl))
+            return true;
+        await sleep(500);
+    }
+    return false;
+}
+export async function ensureCursorCdp(opts = {}) {
+    const cdpUrl = opts.cdpUrl ?? 'http://127.0.0.1:9222';
+    if (await cdpReachable(cdpUrl)) {
+        return true;
+    }
+    const running = isCursorRunning();
+    if (!running) {
+        console.log('[cursorconnect] Cursor не запущен — старт с --remote-debugging-port=9222…');
+        launchCursorWithCdp();
+        return waitCdp(cdpUrl, 50);
+    }
+    // Cursor запущен, CDP недоступен
+    let shouldRestart = Boolean(opts.restartCursor);
+    if (!shouldRestart) {
+        if (!process.stdin.isTTY) {
+            console.warn('[cursorconnect] Cursor без CDP (нет интерактивного терминала).');
+            printManualCdpInstructions();
+            return false;
+        }
+        shouldRestart = await askYesNo('Cursor запущен без CDP. Перезапустить с --remote-debugging-port=9222? (y/n): ');
+    }
+    if (!shouldRestart) {
+        printManualCdpInstructions();
+        return false;
+    }
+    const quitOk = await quitCursor();
+    if (!quitOk) {
+        console.warn('[cursorconnect] Не удалось закрыть Cursor.');
+        printManualCdpInstructions();
+        return false;
+    }
+    console.log('[cursorconnect] Запуск Cursor с --remote-debugging-port=9222…');
+    launchCursorWithCdp();
+    if (await waitCdp(cdpUrl, 50))
+        return true;
+    printManualCdpInstructions();
+    return false;
+}
+async function cdpReachable(cdpUrl) {
+    try {
+        const res = await fetch(`${cdpUrl.replace(/\/$/, '')}/json/version`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/pairing-identity.js

@@ -0,0 +1,80 @@
+import { randomBytes, randomUUID } from 'crypto';
+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;
+}
+export function loadPairingIdentity() {
+    if (!existsSync(FILE))
+        return null;
+    try {
+        const raw = readFileSync(FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!data.roomId || !data.clientToken)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function ensurePairingIdentity(machineLabel) {
+    const existing = loadPairingIdentity();
+    if (existing) {
+        return refreshPairingCode(existing, machineLabel);
+    }
+    const now = new Date().toISOString();
+    const created = {
+        roomId: randomUUID(),
+        clientToken: randomBytes(32).toString('hex'),
+        machineLabel: machineLabel?.trim() || defaultMachineLabel(),
+        pairingCode: formatPairingCode(),
+        pairingCodeExpiresAt: Date.now() + 10 * 60_000,
+        createdAt: now,
+        updatedAt: now,
+    };
+    savePairingIdentity(created);
+    return created;
+}
+export function refreshPairingCode(identity, machineLabel) {
+    const next = {
+        ...identity,
+        machineLabel: machineLabel?.trim() || identity.machineLabel,
+        pairingCode: formatPairingCode(),
+        pairingCodeExpiresAt: Date.now() + 10 * 60_000,
+        updatedAt: new Date().toISOString(),
+    };
+    savePairingIdentity(next);
+    return next;
+}
+function defaultMachineLabel() {
+    return hostname().replace(/\.local$/i, '') || 'Mac';
+}
+export function savePairingIdentity(identity) {
+    mkdirSync(DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(FILE, JSON.stringify(identity, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(FILE, 0o600);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function buildPairUri(relayUrl, identity) {
+    const base = relayUrl.replace(/\/$/, '');
+    const q = new URLSearchParams({
+        v: '1',
+        relay: base,
+        room: identity.roomId,
+        token: identity.clientToken,
+        label: identity.machineLabel,
+    });
+    return `cursorconnect://pair?${q.toString()}`;
+}

package/dist/paths.js

@@ -0,0 +1,6 @@
+import { homedir } from 'os';
+import { join } from 'path';
+export const CURSORCONNECT_DIR = join(homedir(), '.cursorconnect');
+export const IDENTITY_FILE = join(CURSORCONNECT_DIR, 'identity.json');
+export const BRIDGE_PID_FILE = join(CURSORCONNECT_DIR, 'bridge.pid');
+export const BRIDGE_LOG_FILE = join(CURSORCONNECT_DIR, 'bridge.log');

package/dist/print-pairing.js

@@ -0,0 +1,31 @@
+import qrTerminal from 'qrcode-terminal';
+import { buildPairUri } from './pairing-identity.js';
+export function printPairingToTerminal(relayUrl, identity, status) {
+    const pairUri = buildPairUri(relayUrl, identity);
+    const expiresIn = Math.max(0, Math.floor((identity.pairingCodeExpiresAt - Date.now()) / 1000));
+    const ok = status.bridge && status.cdp && status.connector;
+    console.log('\n────────────────────────────────────────');
+    console.log(`  Mac: ${identity.machineLabel}`);
+    console.log(`  Relay: ${relayUrl}`);
+    console.log('');
+    console.log('  Код в приложении (6 цифр):');
+    console.log(`\n       ${identity.pairingCode}\n`);
+    console.log('  QR (скан в CursorConnect → Подключить Mac):\n');
+    qrTerminal.generate(pairUri, { small: true });
+    console.log('');
+    console.log(`  Ссылка (вставить вручную):\n  ${pairUri}\n`);
+    console.log(`  Код действует ~${Math.floor(expiresIn / 60)} мин`);
+    console.log(`  Статус: bridge ${dot(status.bridge)}  CDP ${dot(status.cdp)}  relay ${dot(status.connector)}`);
+    if (!ok) {
+        console.log('  Подождите 10–20 с и снова: npm run connect:status');
+    }
+    else {
+        console.log('  Готово — подключайте телефон.');
+    }
+    console.log('────────────────────────────────────────');
+    console.log('  Bridge в фоне. Остановка: npm run connect:stop');
+    console.log('  Консоль можно закрыть.\n');
+}
+function dot(ok) {
+    return ok ? '✓' : '…';
+}

package/dist/repo-root.js

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+const CONFIG_DIR = join(homedir(), '.cursorconnect');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+export function loadInstallConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+        if (!data.repoRoot || !isValidRepoRoot(data.repoRoot))
+            return null;
+        return { repoRoot: resolve(data.repoRoot) };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveInstallConfig(repoRoot) {
+    const abs = resolve(repoRoot);
+    if (!isValidRepoRoot(abs)) {
+        throw new Error(`Не найден bridge в ${abs} (ожидается …/bridge/package.json)`);
+    }
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CONFIG_FILE, JSON.stringify({ repoRoot: abs }, null, 2), { mode: 0o600 });
+}
+export function isValidRepoRoot(dir) {
+    return existsSync(join(dir, 'bridge', 'package.json'));
+}
+/** Monorepo dev: connect package inside repo */
+function devRepoRoot() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidate = resolve(here, '..', '..');
+    return isValidRepoRoot(candidate) ? candidate : null;
+}
+function findRepoFromCwd() {
+    let dir = process.cwd();
+    for (let i = 0; i < 12; i++) {
+        if (isValidRepoRoot(dir))
+            return resolve(dir);
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function resolveRepoRoot() {
+    const fromEnv = process.env.CURSORCONNECT_ROOT?.trim();
+    if (fromEnv && isValidRepoRoot(fromEnv))
+        return resolve(fromEnv);
+    const fromConfig = loadInstallConfig();
+    if (fromConfig)
+        return fromConfig.repoRoot;
+    const fromCwd = findRepoFromCwd();
+    if (fromCwd)
+        return fromCwd;
+    const fromDev = devRepoRoot();
+    if (fromDev)
+        return fromDev;
+    throw new Error('Не найден CursorConnect (bridge).\n' +
+        '  npm install -g cursorconnect\n' +
+        '  git clone <repo> && cd CursorConnect && npm install\n' +
+        '  cursorconnect init /path/to/CursorConnect\n' +
+        'или: export CURSORCONNECT_ROOT=/path/to/CursorConnect');
+}
+export function configFilePath() {
+    return CONFIG_FILE;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "cursorconnect",
+  "version": "0.1.0",
+  "description": "Mac CLI: CursorConnect bridge, relay pairing (QR + code), Cursor CDP",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cursorconnect": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "cursor",
+    "cursorconnect",
+    "cursor-ide",
+    "bridge",
+    "relay"
+  ],
+  "dependencies": {
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}