cursorconnect 0.1.2 → 0.1.4

package/bridge-runtime/dist/relay.js

@@ -4,10 +4,14 @@ import { randomBytes, timingSafeEqual } from 'crypto';
 import { basename } from 'path';
 import { readAllowedMediaFile, resolveMediaPathParam } from './media-path.js';
 import { Server as SocketServer } from 'socket.io';
+import { ChatDisplayStore } from './chat-display-store.js';
+import { filterClientDisplayList, prepareChatMessagesForDisplay, } from './chat-display.js';
+import { isChatSyncedWithCursor } from './chat-sync.js';
 import { mergeSidebarWithJsonl } from './sidebar-merge.js';
 import { transcribeAudioBuffer } from './openai-transcribe.js';
 import { extensionForMime, saveUploadedImage } from './image-upload-store.js';
 import { RelayUpstream } from './relay-upstream.js';
+import { bridgePipelineLog, bridgePipelineReportLines, bridgePipelineSnapshot, } from './history-pipeline-log.js';
 export class Relay {
     stateManager;
     commandExecutor;
@@ -16,12 +20,17 @@ export class Relay {
     messageDebugStore;
     domExtractor;
     lastJsonlIndex = { repos: [], updatedAt: 0 };
+    indexEmitTimer = null;
+    lastIndexBroadcastAt = 0;
+    lastSidebarIndexKey = '';
+    lastJsonlIndexKey = '';
     config;
     app = express();
     httpServer = createServer(this.app);
     io;
     tokens = new Set();
     upstream = null;
+    chatDisplay = new ChatDisplayStore();
     constructor(config, stateManager, commandExecutor, cdpBridge, jsonlIndex, messageDebugStore, domExtractor) {
         this.stateManager = stateManager;
         this.commandExecutor = commandExecutor;
@@ -32,6 +41,7 @@ export class Relay {
         this.config = config;
         this.io = new SocketServer(this.httpServer, {
             cors: { origin: true, credentials: true },
+            maxHttpBufferSize: 20e6,
         });
         this.setupHttp();
         this.setupSocket();
@@ -82,6 +92,91 @@ export class Relay {
                 lastError: state.lastError,
             });
         });
+        this.app.get('/api/agents/index', async (req, res) => {
+            if (!this.checkMediaAuth(req)) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            try {
+                const stale = Date.now() - (this.lastJsonlIndex.updatedAt ?? 0) > 60_000;
+                const index = this.lastJsonlIndex.repos.length && !stale
+                    ? this.lastJsonlIndex
+                    : await this.jsonlIndex.rebuild({ broadcast: false });
+                this.lastJsonlIndex = index;
+                const merged = mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, index, this.stateManager.getState().composerIdByTitle);
+                const bytes = JSON.stringify(merged).length;
+                bridgePipelineLog({
+                    dir: 'out',
+                    event: 'http:agents:index',
+                    bytes,
+                    detail: `repos=${merged.repos?.length ?? 0}`,
+                });
+                res.json(merged);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        this.app.get('/api/agents/history', async (req, res) => {
+            if (!this.checkMediaAuth(req)) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            const agentId = String(req.query.agentId ?? '').trim();
+            const title = typeof req.query.title === 'string' ? req.query.title.trim() : undefined;
+            const limitRaw = Number(req.query.limit ?? 0);
+            const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : undefined;
+            const requestId = typeof req.query.requestId === 'string' ? req.query.requestId.trim() : undefined;
+            if (!agentId) {
+                res.status(400).json({ error: 'agentId required' });
+                return;
+            }
+            bridgePipelineLog({
+                dir: 'in',
+                event: 'http:agents:history',
+                requestId,
+                agentId,
+                detail: `limit=${limit ?? 'all'} title=${title?.slice(0, 32) ?? '-'}`,
+            });
+            try {
+                const history = await this.jsonlIndex.loadHistory(agentId, {
+                    title,
+                    composerIdByTitle: this.stateManager.getState().composerIdByTitle,
+                    limit,
+                });
+                const messages = this.chatDisplay.applyHistory(agentId, history.messages);
+                const body = { ...history, messages, requestId, updatedAt: Date.now() };
+                const bytes = JSON.stringify(body).length;
+                bridgePipelineLog({
+                    dir: 'out',
+                    event: 'http:agents:history',
+                    requestId,
+                    agentId,
+                    bytes,
+                    msgs: history.messages?.length ?? 0,
+                    detail: `total=${history.totalMessages ?? '?'}`,
+                });
+                res.json(body);
+            }
+            catch (err) {
+                bridgePipelineLog({
+                    dir: 'internal',
+                    event: 'http:agents:history:ERR',
+                    requestId,
+                    agentId,
+                    detail: err.message,
+                });
+                res.status(500).json({ error: err.message });
+            }
+        });
+        this.app.get('/api/debug/history-pipeline', (_req, res) => {
+            res.json({
+                ok: true,
+                at: Date.now(),
+                lines: bridgePipelineReportLines(),
+                entries: bridgePipelineSnapshot(),
+            });
+        });
         this.app.get('/media/file', (req, res) => {
             if (!this.checkMediaAuth(req)) {
                 res.status(401).json({ error: 'Unauthorized' });
@@ -212,37 +307,108 @@ export class Relay {
         this.io.on('connection', (socket) => this.onConnect(socket));
     }
     broadcast(event, payload) {
+        if (event === 'agents:history' || event === 'agent:history') {
+            const h = payload;
+            const bytes = JSON.stringify(payload ?? {}).length;
+            bridgePipelineLog({
+                dir: 'out',
+                event: `broadcast:${event}`,
+                requestId: h?.requestId,
+                agentId: h?.agentId,
+                bytes,
+                msgs: h?.messages?.length ?? 0,
+                detail: `upstream=${this.upstream?.connected ?? false}`,
+            });
+        }
         this.io.emit(event, payload);
         this.upstream?.emit(event, payload);
     }
+    prepareStateMessages(raw, patch) {
+        const state = { ...this.stateManager.getState(), ...patch };
+        for (const [agentId, meta] of this.jsonlIndex.getSubscribedAgents()) {
+            if (isChatSyncedWithCursor(agentId, meta.title, state)) {
+                return this.chatDisplay.mergeLiveForAgent(agentId, raw);
+            }
+        }
+        return filterClientDisplayList(prepareChatMessagesForDisplay(raw));
+    }
+    withDisplayState(payload) {
+        if (!payload.messages?.length)
+            return payload;
+        return {
+            ...payload,
+            messages: this.prepareStateMessages(payload.messages, payload),
+        };
+    }
     wireEvents() {
         this.stateManager.on('state:full', (state) => {
-            this.broadcast('state:full', state);
+            this.broadcast('state:full', this.withDisplayState(state));
             this.emitAgentsIndex();
         });
         this.stateManager.on('state:patch', (patch) => {
-            this.broadcast('state:patch', patch);
-            if (patch.sidebarRepos || patch.composerIdByTitle)
-                this.emitAgentsIndex();
+            this.broadcast('state:patch', this.withDisplayState(patch));
+            if (patch.sidebarRepos || patch.composerIdByTitle) {
+                const key = JSON.stringify([patch.sidebarRepos, patch.composerIdByTitle]);
+                if (key !== this.lastSidebarIndexKey) {
+                    this.lastSidebarIndexKey = key;
+                    this.emitAgentsIndex();
+                }
+            }
         });
         this.jsonlIndex.on('agents:index', (index) => {
+            const key = JSON.stringify(index.repos?.map((r) => [r.id, r.agents.length]));
+            if (key === this.lastJsonlIndexKey)
+                return;
+            this.lastJsonlIndexKey = key;
             this.lastJsonlIndex = index;
             this.emitAgentsIndex();
         });
-        this.jsonlIndex.on('agent:history', (history) => this.broadcast('agent:history', history));
+        this.jsonlIndex.on('agent:history', (history) => {
+            const messages = this.chatDisplay.applyHistory(history.agentId, history.messages, {
+                mergeWithCache: true,
+            });
+            this.broadcast('agent:history', { ...history, messages });
+        });
     }
-    emitAgentsIndex() {
-        const sidebar = this.stateManager.getState().sidebarRepos;
-        const merged = mergeSidebarWithJsonl(sidebar, this.lastJsonlIndex, this.stateManager.getState().composerIdByTitle);
-        this.broadcast('agents:index', merged);
+    emitAgentsIndex(force = false) {
+        const send = () => {
+            const merged = mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, this.lastJsonlIndex, this.stateManager.getState().composerIdByTitle);
+            this.broadcast('agents:index', merged);
+            this.lastIndexBroadcastAt = Date.now();
+        };
+        if (force) {
+            if (this.indexEmitTimer)
+                clearTimeout(this.indexEmitTimer);
+            this.indexEmitTimer = null;
+            send();
+            return;
+        }
+        const elapsed = Date.now() - this.lastIndexBroadcastAt;
+        if (elapsed >= 60_000) {
+            send();
+            return;
+        }
+        if (this.indexEmitTimer)
+            return;
+        this.indexEmitTimer = setTimeout(() => {
+            this.indexEmitTimer = null;
+            send();
+        }, 60_000 - elapsed);
     }
-    pushFullStateToRemote() {
-        this.broadcast('state:full', this.stateManager.getState());
-        void this.jsonlIndex.rebuild().then((index) => {
+    refreshAgentsIndex(force = false) {
+        void this.jsonlIndex.rebuild({ broadcast: false }).then((index) => {
             this.lastJsonlIndex = index;
-            this.broadcast('agents:index', mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, index, this.stateManager.getState().composerIdByTitle));
+            this.emitAgentsIndex(force);
         });
     }
+    pushFullStateToRemote() {
+        this.broadcast('state:full', this.withDisplayState(this.stateManager.getState()));
+        if (this.lastJsonlIndex.updatedAt > 0) {
+            this.emitAgentsIndex(true);
+            return;
+        }
+        this.refreshAgentsIndex(true);
+    }
     async trySwitchWindowForAgent(agentId) {
         const projectDir = this.jsonlIndex.findProjectDirForAgent(agentId);
         if (!projectDir)
@@ -273,11 +439,19 @@ export class Relay {
         this.dispatchClientEvent(event, args, reply);
     }
     onConnect(socket) {
-        socket.emit('state:full', this.stateManager.getState());
-        void this.jsonlIndex.rebuild().then((index) => {
-            this.lastJsonlIndex = index;
+        socket.emit('state:full', this.withDisplayState(this.stateManager.getState()));
+        const sendIndex = (index) => {
             socket.emit('agents:index', mergeSidebarWithJsonl(this.stateManager.getState().sidebarRepos, index, this.stateManager.getState().composerIdByTitle));
-        });
+        };
+        if (this.lastJsonlIndex.updatedAt > 0) {
+            sendIndex(this.lastJsonlIndex);
+        }
+        else {
+            void this.jsonlIndex.rebuild({ broadcast: false }).then((index) => {
+                this.lastJsonlIndex = index;
+                sendIndex(index);
+            });
+        }
         const reply = (ev, payload) => {
             socket.emit(ev, payload);
         };
@@ -297,7 +471,7 @@ export class Relay {
             await this.runAgentsFocus(data, reply);
         });
         socket.on('agents:refresh', () => {
-            void this.jsonlIndex.rebuild();
+            this.refreshAgentsIndex(true);
         });
         socket.on('disconnect', () => {
             /* subscriptions stay global — one phone session typical */
@@ -325,7 +499,7 @@ export class Relay {
             return;
         }
         if (event === 'agents:refresh') {
-            void this.jsonlIndex.rebuild();
+            this.refreshAgentsIndex(true);
         }
     }
     async runCommand(payload, reply) {
@@ -353,12 +527,65 @@ export class Relay {
             this.domExtractor.pollNow();
         }
     }
-    async runAgentsHistory({ agentId, title }, reply) {
-        const history = await this.jsonlIndex.loadHistory(agentId, {
-            title,
-            composerIdByTitle: this.stateManager.getState().composerIdByTitle,
+    async runAgentsHistory({ agentId, title, requestId, limit, }, reply) {
+        const t0 = Date.now();
+        const viaUpstream = this.upstream?.connected ?? false;
+        const socketLimit = limit && limit > 0 ? limit : 15;
+        console.log(`[relay] agents:history req agentId=${agentId} title=${title?.slice(0, 48) ?? '-'} limit=${socketLimit} rid=${requestId ?? '-'} upstream=${viaUpstream}`);
+        this.jsonlIndex.historyReplyInFlight.add(agentId);
+        bridgePipelineLog({
+            dir: 'in',
+            event: 'agents:history:req',
+            requestId,
+            agentId,
+            detail: `limit=${socketLimit} title=${title?.slice(0, 32) ?? '-'} upstream=${viaUpstream}`,
         });
-        reply('agents:history', history);
+        try {
+            const history = await this.jsonlIndex.loadHistory(agentId, {
+                title,
+                composerIdByTitle: this.stateManager.getState().composerIdByTitle,
+                limit: socketLimit,
+            });
+            const messages = this.chatDisplay.applyHistory(agentId, history.messages);
+            const ms = Date.now() - t0;
+            const bytes = JSON.stringify(messages).length;
+            console.log(`[relay] agents:history ok agentId=${history.agentId} msgs=${history.messages?.length ?? 0}/${history.totalMessages ?? '?'} bytes=${bytes} ms=${ms} rid=${requestId ?? '-'}`);
+            bridgePipelineLog({
+                dir: 'out',
+                event: 'agents:history:reply',
+                requestId,
+                agentId: history.agentId,
+                bytes,
+                msgs: history.messages?.length ?? 0,
+                detail: `total=${history.totalMessages ?? '?'} ms=${ms}`,
+            });
+            reply('agents:history', {
+                ...history,
+                messages,
+                requestId,
+                updatedAt: Date.now(),
+            });
+        }
+        catch (err) {
+            console.error(`[relay] agents:history fail agentId=${agentId} ms=${Date.now() - t0} rid=${requestId ?? '-'}:`, err.message);
+            bridgePipelineLog({
+                dir: 'internal',
+                event: 'agents:history:fail',
+                requestId,
+                agentId,
+                detail: err.message,
+            });
+            reply('agents:history', {
+                agentId,
+                messages: [],
+                totalMessages: 0,
+                requestId,
+                updatedAt: Date.now(),
+            });
+        }
+        finally {
+            this.jsonlIndex.historyReplyInFlight.delete(agentId);
+        }
     }
     async runAgentsSubscribe({ agentId, title, focus, }) {
         if (!agentId)
@@ -379,8 +606,10 @@ export class Relay {
         }
     }
     runAgentsUnsubscribe({ agentId }) {
-        if (agentId)
+        if (agentId) {
             this.jsonlIndex.unsubscribe(agentId);
+            this.chatDisplay.clearAgent(agentId);
+        }
     }
     async runAgentsFocus({ agentId, title }, reply) {
         if (!agentId)

package/bridge-runtime/dist/sidebar-merge.js

@@ -3,7 +3,7 @@ export { normalizeAgentTitle } from './agent-title-match.js';
 /** Prefer Cursor DOM sidebar order/names; attach JSONL ids when titles match. */
 export function mergeSidebarWithJsonl(sidebarRepos, jsonl, composerIdByTitle) {
     if (!sidebarRepos?.length)
-        return jsonl;
+        return { ...jsonl, listSource: 'jsonl' };
     const byTitle = new Map();
     for (const repo of jsonl.repos) {
         for (const agent of repo.agents) {
@@ -43,5 +43,5 @@ export function mergeSidebarWithJsonl(sidebarRepos, jsonl, composerIdByTitle) {
             };
         }),
     }));
-    return { repos, updatedAt: Date.now() };
+    return { repos, updatedAt: Date.now(), listSource: 'sidebar' };
 }

package/bridge-runtime/dist/types.d.ts

@@ -229,15 +229,23 @@ export interface RepoGroup {
 export interface AgentsIndex {
     repos: RepoGroup[];
     updatedAt: number;
+    /** `sidebar` = порядок/названия из CDP; `jsonl` = архив на диске (не как в Cursor). */
+    listSource?: 'sidebar' | 'jsonl';
 }
 export interface HistoryMessage {
     role: 'user' | 'assistant' | 'system';
     text: string;
+    html?: string;
+    /** Absolute paths from JSONL `<image_files>` (served via GET /media/file). */
+    images?: string[];
     ts?: number;
 }
 export interface AgentHistory {
     agentId: string;
-    messages: HistoryMessage[];
+    /** Display-ready chat rows (normalized, deduped, filtered on bridge). */
+    messages: ChatMessage[];
     updatedAt?: number;
+    requestId?: string;
+    totalMessages?: number;
 }
 export type ExtractedPageState = Omit<CursorState, 'connected' | 'windows' | 'activeWindowId' | 'windowSnapshots' | 'updatedAt'>;

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/bridge-dir.js

@@ -65,6 +65,11 @@ export function ensureUserConfig() {
         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);

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');
+}