cursorconnect 0.1.2 → 0.1.5

package/bridge-runtime/dist/history-pipeline-log.js

@@ -0,0 +1,29 @@
+const RING = [];
+const MAX = 150;
+export function bridgePipelineLog(entry) {
+    const row = {
+        layer: 'bridge',
+        at: entry.at ?? Date.now(),
+        dir: entry.dir,
+        event: entry.event,
+        requestId: entry.requestId,
+        agentId: entry.agentId,
+        bytes: entry.bytes,
+        msgs: entry.msgs,
+        detail: entry.detail,
+    };
+    RING.push(row);
+    while (RING.length > MAX)
+        RING.shift();
+    const rid = row.requestId ? ` rid=${row.requestId}` : '';
+    console.log(`[history-pipe] bridge ${row.dir} ${row.event}${rid} agent=${row.agentId ?? '-'} bytes=${row.bytes ?? '-'} msgs=${row.msgs ?? '-'} ${row.detail ?? ''}`.trim());
+}
+export function bridgePipelineSnapshot() {
+    return [...RING];
+}
+export function bridgePipelineReportLines() {
+    return RING.map((r) => {
+        const t = new Date(r.at).toISOString().slice(11, 23);
+        return `${t} bridge ${r.dir} ${r.event} rid=${r.requestId ?? '-'} agent=${r.agentId ?? '-'} bytes=${r.bytes ?? '-'} msgs=${r.msgs ?? '-'} ${r.detail ?? ''}`.trim();
+    });
+}

package/bridge-runtime/dist/jsonl-index.d.ts

@@ -1,24 +1,36 @@
 import { EventEmitter } from 'events';
-import type { AgentHistory, AgentsIndex } from './types.js';
+import type { AgentsIndex, HistoryMessage } from './types.js';
 export declare class JsonlIndex extends EventEmitter {
     private projectsDir;
     private debounceTimer;
     private subscribed;
     private mtimeByAgent;
     private pollTimer;
+    /** Skip poll `agent:history` while serving explicit `agents:history` (avoids relay race). */
+    readonly historyReplyInFlight: Set<string>;
     constructor(projectsDir: string);
     start(): void;
     stop(): void;
     subscribe(agentId: string, title?: string): void;
     unsubscribe(agentId: string): void;
+    getSubscribedAgents(): ReadonlyMap<string, {
+        title?: string;
+    }>;
     private pollSubscribed;
     private emitHistoryForAgent;
     private emitHistoryForFile;
     private scheduleRebuild;
-    rebuild(): Promise<AgentsIndex>;
+    rebuild(opts?: {
+        broadcast?: boolean;
+    }): Promise<AgentsIndex>;
     findProjectDirForAgent(agentId: string): string | null;
     loadHistory(agentId: string, opts?: {
         title?: string;
         composerIdByTitle?: Record<string, string>;
-    }): Promise<AgentHistory>;
+        limit?: number;
+    }): Promise<{
+        agentId: string;
+        messages: HistoryMessage[];
+        totalMessages: number;
+    }>;
 }

package/bridge-runtime/dist/jsonl-index.js

@@ -4,13 +4,16 @@ import { basename, join } from 'path';
 import { createInterface } from 'readline';
 import chokidar from 'chokidar';
 import { resolveJsonlFilePath } from './agent-title-match.js';
-import { cleanUserText, filterAssistantJsonlParts, isNoiseChatText, } from './message-filter.js';
+import { cleanUserText, parseUserImagePaths, filterAssistantJsonlParts, isNoiseChatText, stripJsonlRedactionArtifacts, } from './message-filter.js';
+import { bridgePipelineLog } from './history-pipeline-log.js';
 export class JsonlIndex extends EventEmitter {
     projectsDir;
     debounceTimer = null;
     subscribed = new Map();
     mtimeByAgent = new Map();
     pollTimer = null;
+    /** Skip poll `agent:history` while serving explicit `agents:history` (avoids relay race). */
+    historyReplyInFlight = new Set();
     constructor(projectsDir) {
         super();
         this.projectsDir = projectsDir;
@@ -44,6 +47,9 @@ export class JsonlIndex extends EventEmitter {
         this.subscribed.delete(agentId);
         this.mtimeByAgent.delete(agentId);
     }
+    getSubscribedAgents() {
+        return this.subscribed;
+    }
     async pollSubscribed() {
         for (const [agentId, meta] of this.subscribed) {
             const filePath = resolveJsonlFilePath(this.projectsDir, agentId, {
@@ -57,7 +63,7 @@ export class JsonlIndex extends EventEmitter {
                 if (prev === mtime)
                     continue;
                 this.mtimeByAgent.set(agentId, mtime);
-                await this.emitHistoryForFile(filePath);
+                await this.emitHistoryForFile(filePath, agentId);
             }
             catch {
                 /* skip */
@@ -83,6 +89,15 @@ export class JsonlIndex extends EventEmitter {
         if (!fileAgentId || fileAgentId.includes('/'))
             return;
         const agentId = replyAgentId ?? fileAgentId;
+        if (this.historyReplyInFlight.has(agentId) || this.historyReplyInFlight.has(fileAgentId)) {
+            bridgePipelineLog({
+                dir: 'internal',
+                event: 'poll:agent:history:SKIP',
+                agentId,
+                detail: `inFlight file=${fileAgentId.slice(0, 8)}`,
+            });
+            return;
+        }
         try {
             const messages = await parseJsonlFile(filePath);
             this.mtimeByAgent.set(agentId, statSync(filePath).mtimeMs);
@@ -97,11 +112,13 @@ export class JsonlIndex extends EventEmitter {
             clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(() => void this.rebuild(), 500);
     }
-    async rebuild() {
+    async rebuild(opts) {
+        const broadcast = opts?.broadcast !== false;
         const repos = new Map();
         if (!existsSync(this.projectsDir)) {
             const empty = { repos: [], updatedAt: Date.now() };
-            this.emit('agents:index', empty);
+            if (broadcast)
+                this.emit('agents:index', empty);
             return empty;
         }
         for (const entry of readdirSync(this.projectsDir, { withFileTypes: true })) {
@@ -126,8 +143,10 @@ export class JsonlIndex extends EventEmitter {
         const index = {
             repos: [...repos.values()].sort((a, b) => a.name.localeCompare(b.name)),
             updatedAt: Date.now(),
+            listSource: 'jsonl',
         };
-        this.emit('agents:index', index);
+        if (broadcast)
+            this.emit('agents:index', index);
         return index;
     }
     findProjectDirForAgent(agentId) {
@@ -142,10 +161,15 @@ export class JsonlIndex extends EventEmitter {
     async loadHistory(agentId, opts) {
         const filePath = resolveJsonlFilePath(this.projectsDir, agentId, opts);
         if (!filePath) {
-            return { agentId, messages: [] };
+            return { agentId, messages: [], totalMessages: 0 };
         }
         const messages = await parseJsonlFile(filePath);
-        return { agentId, messages };
+        const totalMessages = messages.length;
+        const limit = opts?.limit;
+        const trimmed = limit && limit > 0 && messages.length > limit
+            ? messages.slice(-limit)
+            : messages;
+        return { agentId, messages: trimmed, totalMessages };
     }
 }
 function shouldIgnoreWatchPath(p) {
@@ -207,7 +231,7 @@ function peekFirstUserMessage(filePath) {
             if (row.role !== 'user')
                 continue;
             const text = row.message?.content?.find((c) => c.type === 'text')?.text ?? '';
-            const cleaned = text.replace(/<user_query>\s*/gi, '').replace(/<\/user_query>/gi, '').trim();
+            const cleaned = cleanUserText(text);
             if (cleaned)
                 return cleaned.slice(0, 200);
         }
@@ -272,8 +296,10 @@ async function parseJsonlFile(filePath) {
         try {
             const row = JSON.parse(line);
             const parts = [];
+            const rawParts = [];
             for (const c of row.message?.content ?? []) {
                 if (c.type === 'text' && c.text) {
+                    rawParts.push(c.text);
                     const t = cleanUserText(c.text);
                     if (t)
                         parts.push(t);
@@ -281,10 +307,20 @@ async function parseJsonlFile(filePath) {
                 // tool_use, tool_result — ignore
             }
             if (row.role === 'user') {
-                const text = parts.join('\n').trim();
-                if (text && !isNoiseChatText(text)) {
-                    messages.push({ role: 'user', text, ts: lineNo });
-                }
+                const raw = rawParts.join('\n');
+                const images = parseUserImagePaths(raw);
+                const text = stripJsonlRedactionArtifacts(cleanUserText(parts.join('\n').trim()));
+                const hasImages = images.length > 0;
+                if ((!text || isNoiseChatText(text)) && !hasImages)
+                    continue;
+                if (text && isNoiseChatText(text) && !hasImages)
+                    continue;
+                messages.push({
+                    role: 'user',
+                    text: text || (hasImages ? 'Изображение' : ''),
+                    images: hasImages ? images : undefined,
+                    ts: lineNo,
+                });
                 continue;
             }
             if (row.role === 'assistant') {

package/bridge-runtime/dist/message-filter.d.ts

@@ -9,11 +9,21 @@ export declare const WORKING_STATUS_LINE: RegExp;
 /** Short DOM status line only — not a sentence inside a chat message. */
 export declare function matchBackgroundWorkStatusText(text: string): string | undefined;
 export declare function isBackgroundWorkStatusText(text: string): boolean;
+/** Chat line that is only passive-work status (not prose mentioning it). */
+export declare function isPassiveStatusChatLine(text: string): boolean;
 /** DOM/system lines that mean the agent is still busy */
 export declare function textImpliesAgentWorking(text: string): boolean;
+/** Cursor JSONL redacts tool/thinking tails as `[REDACTED]` — not shown in live DOM. */
+export declare function stripJsonlRedactionArtifacts(text: string): string;
 export declare function isNoiseChatText(text: string): boolean;
+/** Chain-of-thought / tool trace rows — not user-facing answers (DOM + JSONL). */
+export declare function isAssistantReflectionText(text: string): boolean;
 /** Short agent status worth showing (not tool log). */
 export declare function isMeaningfulAssistantText(text: string): boolean;
+/** Paths from Cursor `<image_files>` blocks (JSONL + DOM text). */
+export declare function parseUserImagePaths(text: string): string[];
+/** Cursor injects image metadata into user bubbles — hide it in the app. */
+export declare function stripUserImageMetadata(text: string): string;
 /** Keep in sync with `cleanUserText` in `extract-page.ts` (CDP runs in-page). */
 export declare function cleanUserText(text: string): string;
 export declare function filterAssistantJsonlParts(parts: string[]): string[];

package/bridge-runtime/dist/message-filter.js

@@ -22,12 +22,28 @@ export function matchBackgroundWorkStatusText(text) {
 export function isBackgroundWorkStatusText(text) {
     return matchBackgroundWorkStatusText(text) !== undefined;
 }
+/** Chat line that is only passive-work status (not prose mentioning it). */
+export function isPassiveStatusChatLine(text) {
+    const t = text.trim().replace(/\s+/g, ' ');
+    if (!t || t.length > 80 || t.includes('?'))
+        return false;
+    if (BACKGROUND_WORK_STATUS.test(t) || WORKING_STATUS_LINE.test(t))
+        return true;
+    return false;
+}
 /** DOM/system lines that mean the agent is still busy */
 export function textImpliesAgentWorking(text) {
     return isBackgroundWorkStatusText(text);
 }
+/** Cursor JSONL redacts tool/thinking tails as `[REDACTED]` — not shown in live DOM. */
+export function stripJsonlRedactionArtifacts(text) {
+    return text
+        .replace(/(?:\n|\r\n)*\[REDACTED\]\s*$/g, '')
+        .replace(/^\[REDACTED\]\s*$/g, '')
+        .trim();
+}
 export function isNoiseChatText(text) {
-    const t = text.trim().replace(/\s+/g, ' ');
+    const t = stripJsonlRedactionArtifacts(text).trim().replace(/\s+/g, ' ');
     if (!t || t.length < 2)
         return true;
     if (NOISE_LINE.test(t))
@@ -56,10 +72,29 @@ export function isNoiseChatText(text) {
         return true;
     return false;
 }
+/** Chain-of-thought / tool trace rows — not user-facing answers (DOM + JSONL). */
+export function isAssistantReflectionText(text) {
+    const t = stripJsonlRedactionArtifacts(text).trim().replace(/\s+/g, ' ');
+    if (!t || isNoiseChatText(t))
+        return true;
+    if (/^Thought\s*for\s*\d/i.test(t) && t.length < 160)
+        return true;
+    if (/^(Exploring|Grepped|Searched|Listed|Read |Ran |Edited |Loading|Planning|Using image)/i.test(t)) {
+        return true;
+    }
+    const toolHits = t.match(/\b(Explored|Grepped|Searched|Listed|Read )\b/gi);
+    if (toolHits && toolHits.length >= 2)
+        return true;
+    if (t.length > 160 &&
+        /\b(state\.messages|flat-index|mapKeyedChildren|humanEl|extract-page|userMessagesEquivalent)\b/i.test(t)) {
+        return true;
+    }
+    return false;
+}
 /** Short agent status worth showing (not tool log). */
 export function isMeaningfulAssistantText(text) {
     const t = text.trim();
-    if (!t || isNoiseChatText(t))
+    if (!t || isNoiseChatText(t) || isAssistantReflectionText(t))
         return false;
     // Markdown prose / explanation
     if (t.length >= 20 && /\s/.test(t))
@@ -69,15 +104,40 @@ export function isMeaningfulAssistantText(text) {
         return true;
     return t.length >= 50;
 }
+/** Paths from Cursor `<image_files>` blocks (JSONL + DOM text). */
+export function parseUserImagePaths(text) {
+    const paths = [];
+    const scope = text.match(/<image_files>[\s\S]*?<\/image_files>/i)?.[0] ?? text;
+    const re = /\d+\.\s+(\/?[^\s\n]+?\.(?:png|jpe?g|gif|webp))/gi;
+    let m;
+    while ((m = re.exec(scope))) {
+        const p = m[1]?.trim();
+        if (p && !paths.includes(p))
+            paths.push(p);
+    }
+    return paths;
+}
+/** Cursor injects image metadata into user bubbles — hide it in the app. */
+export function stripUserImageMetadata(text) {
+    return text
+        .replace(/^\[Image\]\s*$/gim, '')
+        .replace(/<image_files>[\s\S]*?<\/image_files>/gi, '')
+        .replace(/(?:^|\n)\s*The following images? (?:were |has been )?provid(?:ed|ied)[^\n]*(?:\n\s*\d+\.\s*[^\n]+)*/gi, '\n')
+        .replace(/(?:^|\n)\s*These images can be copied for use in other locations\.?\s*/gi, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
 /** Keep in sync with `cleanUserText` in `extract-page.ts` (CDP runs in-page). */
 export function cleanUserText(text) {
-    return text
+    return stripUserImageMetadata(text
         .replace(/<user_query>\s*/gi, '')
         .replace(/<\/user_query>/gi, '')
         .replace(/([.!?…])(\d+\.\s*)/g, '$1\n$2')
         .replace(/([^\n\d\s])(\d+\.\s+)/g, '$1\n$2')
-        .trim();
+        .trim());
 }
 export function filterAssistantJsonlParts(parts) {
-    return parts.filter((p) => isMeaningfulAssistantText(p));
+    return parts
+        .map((p) => stripJsonlRedactionArtifacts(p))
+        .filter((p) => isMeaningfulAssistantText(p));
 }

package/bridge-runtime/dist/pairing-code.d.ts

@@ -0,0 +1,3 @@
+export declare const PAIRING_CODE_LENGTH = 6;
+export declare function generatePairingCode(): string;
+export declare function normalizePairingCode(raw: string): string | null;

package/bridge-runtime/dist/pairing-code.js

@@ -0,0 +1,17 @@
+import { randomBytes } from 'crypto';
+export const PAIRING_CODE_LENGTH = 6;
+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/bridge-runtime/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(),
     };
@@ -58,7 +55,7 @@ export function rotateClientToken(identity) {
     const next = {
         ...identity,
         clientToken: randomBytes(32).toString('hex'),
-        pairingCode: formatPairingCode(),
+        pairingCode: generatePairingCode(),
         pairingCodeExpiresAt: Date.now() + 10 * 60_000,
         updatedAt: new Date().toISOString(),
     };

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

@@ -13,12 +13,17 @@ export declare class Relay {
     private messageDebugStore;
     private domExtractor;
     private lastJsonlIndex;
+    private indexEmitTimer;
+    private lastIndexBroadcastAt;
+    private lastSidebarIndexKey;
+    private lastJsonlIndexKey;
     private config;
     private app;
     private httpServer;
     private io;
     private tokens;
     private upstream;
+    private readonly chatDisplay;
     constructor(config: ServerConfig, stateManager: StateManager, commandExecutor: CommandExecutor, cdpBridge: CDPBridge, jsonlIndex: JsonlIndex, messageDebugStore: MessageDebugStore, domExtractor: DOMExtractor);
     listen(): Promise<void>;
     private get authEnabled();
@@ -26,8 +31,11 @@ export declare class Relay {
     private setupHttp;
     private setupSocket;
     private broadcast;
+    private prepareStateMessages;
+    private withDisplayState;
     private wireEvents;
     private emitAgentsIndex;
+    private refreshAgentsIndex;
     private pushFullStateToRemote;
     private trySwitchWindowForAgent;
     private handleRemoteClientEvent;