cursorconnect 0.1.5 → 0.1.7

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

@@ -4,57 +4,113 @@ import { basename, join } from 'path';
 import { createInterface } from 'readline';
 import chokidar from 'chokidar';
 import { resolveJsonlFilePath } from './agent-title-match.js';
-import { cleanUserText, parseUserImagePaths, filterAssistantJsonlParts, isNoiseChatText, stripJsonlRedactionArtifacts, } from './message-filter.js';
+import { canonicalizeImagePaths } from './media-path.js';
+import { cleanUserText, filterAssistantJsonlParts, isNoiseChatText, parseUserImagePaths, stripJsonlRedactionArtifacts, } from './message-filter.js';
 import { bridgePipelineLog } from './history-pipeline-log.js';
+const JSONL_POLL_MS = parseInt(process.env.JSONL_POLL_MS ?? '120', 10);
+/** Debounce only for non–live-watched files (index rebuild path). */
+const JSONL_EMIT_DEBOUNCE_MS = parseInt(process.env.JSONL_EMIT_DEBOUNCE_MS ?? '0', 10);
+const JSONL_WRITE_STABILITY_MS = parseInt(process.env.JSONL_WRITE_STABILITY_MS ?? '50', 10);
 export class JsonlIndex extends EventEmitter {
     projectsDir;
     debounceTimer = null;
     subscribed = new Map();
     mtimeByAgent = new Map();
     pollTimer = null;
+    fileCache = new Map();
+    emitFileTimers = new Map();
+    liveWatcher = null;
+    liveWatchKey = '';
     /** Skip poll `agent:history` while serving explicit `agents:history` (avoids relay race). */
     historyReplyInFlight = new Set();
+    bridgeState = () => ({ tabs: [] });
     constructor(projectsDir) {
         super();
         this.projectsDir = projectsDir;
     }
+    setBridgeStateProvider(fn) {
+        this.bridgeState = fn;
+    }
+    resolveOpts(title) {
+        const state = this.bridgeState();
+        const activeTab = state.tabs?.find((t) => t.active);
+        return {
+            title,
+            composerIdByTitle: state.composerIdByTitle,
+            activeComposerId: state.activeComposerId,
+            activeTabTitle: activeTab?.title,
+        };
+    }
     start() {
         void this.rebuild();
         chokidar
             .watch(this.projectsDir, {
             ignoreInitial: true,
             depth: 8,
-            awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 100 },
+            awaitWriteFinish: {
+                stabilityThreshold: JSONL_WRITE_STABILITY_MS,
+                pollInterval: 50,
+            },
             ignored: (p) => shouldIgnoreWatchPath(p),
         })
             .on('all', (_event, filePath) => {
             if (!filePath || !filePath.endsWith('.jsonl'))
                 return;
             this.scheduleRebuild();
-            void this.emitHistoryForFile(filePath);
+            this.scheduleEmitHistoryForFile(filePath);
         });
-        this.pollTimer = setInterval(() => void this.pollSubscribed(), 700);
+        this.pollTimer = setInterval(() => void this.pollSubscribed(), JSONL_POLL_MS);
     }
     stop() {
         if (this.pollTimer)
             clearInterval(this.pollTimer);
+        void this.liveWatcher?.close();
+        this.liveWatcher = null;
+        this.liveWatchKey = '';
     }
-    subscribe(agentId, title) {
+    subscribe(agentId, title, opts) {
         this.subscribed.set(agentId, { title });
-        void this.emitHistoryForAgent(agentId, title);
+        this.refreshLiveWatcher();
+        if (opts?.emitHistory !== false) {
+            void this.emitHistoryForAgent(agentId, title);
+        }
     }
     unsubscribe(agentId) {
         this.subscribed.delete(agentId);
         this.mtimeByAgent.delete(agentId);
+        this.refreshLiveWatcher();
+    }
+    /** Immediate `change` on subscribed `.jsonl` (no awaitWriteFinish delay). */
+    refreshLiveWatcher() {
+        const paths = [];
+        for (const [agentId, meta] of this.subscribed) {
+            const p = resolveJsonlFilePath(this.projectsDir, agentId, this.resolveOpts(meta.title));
+            if (p)
+                paths.push(p);
+        }
+        const key = paths.sort().join('\0');
+        if (key === this.liveWatchKey)
+            return;
+        this.liveWatchKey = key;
+        void this.liveWatcher?.close();
+        this.liveWatcher = null;
+        if (!paths.length)
+            return;
+        this.liveWatcher = chokidar.watch(paths, { ignoreInitial: true, persistent: true });
+        const onLive = (filePath) => {
+            if (!filePath.endsWith('.jsonl'))
+                return;
+            void this.emitHistoryForFileNow(filePath);
+        };
+        this.liveWatcher.on('change', onLive);
+        this.liveWatcher.on('add', onLive);
     }
     getSubscribedAgents() {
         return this.subscribed;
     }
     async pollSubscribed() {
         for (const [agentId, meta] of this.subscribed) {
-            const filePath = resolveJsonlFilePath(this.projectsDir, agentId, {
-                title: meta.title,
-            });
+            const filePath = resolveJsonlFilePath(this.projectsDir, agentId, this.resolveOpts(meta.title));
             if (!filePath)
                 continue;
             try {
@@ -63,7 +119,7 @@ export class JsonlIndex extends EventEmitter {
                 if (prev === mtime)
                     continue;
                 this.mtimeByAgent.set(agentId, mtime);
-                await this.emitHistoryForFile(filePath, agentId);
+                void this.emitHistoryForFileNow(filePath, agentId);
             }
             catch {
                 /* skip */
@@ -71,9 +127,14 @@ export class JsonlIndex extends EventEmitter {
         }
     }
     async emitHistoryForAgent(agentId, title) {
-        const filePath = resolveJsonlFilePath(this.projectsDir, agentId, { title });
+        const filePath = resolveJsonlFilePath(this.projectsDir, agentId, this.resolveOpts(title));
         if (!filePath) {
-            this.emit('agent:history', { agentId, messages: [], updatedAt: Date.now() });
+            this.emit('agent:history', {
+                agentId,
+                messages: [],
+                totalMessages: 0,
+                updatedAt: Date.now(),
+            });
             return;
         }
         try {
@@ -82,26 +143,101 @@ export class JsonlIndex extends EventEmitter {
         catch {
             /* ignore */
         }
-        await this.emitHistoryForFile(filePath, agentId);
+        await this.emitHistoryForFileNow(filePath, agentId);
     }
-    async emitHistoryForFile(filePath, replyAgentId) {
+    scheduleEmitHistoryForFile(filePath, replyAgentId) {
+        if (this.isLiveWatchedFile(filePath)) {
+            void this.emitHistoryForFileNow(filePath, replyAgentId);
+            return;
+        }
+        if (JSONL_EMIT_DEBOUNCE_MS <= 0) {
+            void this.emitHistoryForFileNow(filePath, replyAgentId);
+            return;
+        }
+        const key = `${filePath}\0${replyAgentId ?? ''}`;
+        const prev = this.emitFileTimers.get(key);
+        if (prev)
+            clearTimeout(prev);
+        this.emitFileTimers.set(key, setTimeout(() => {
+            this.emitFileTimers.delete(key);
+            void this.emitHistoryForFileNow(filePath, replyAgentId);
+        }, JSONL_EMIT_DEBOUNCE_MS));
+    }
+    isLiveWatchedFile(filePath) {
+        if (!this.liveWatchKey)
+            return false;
+        return this.liveWatchKey.split('\0').includes(filePath);
+    }
+    async loadMessagesForFile(filePath) {
+        const st = statSync(filePath);
+        const cached = this.fileCache.get(filePath);
+        if (cached && cached.size === st.size)
+            return cached.messages;
+        if (cached && st.size > cached.size) {
+            const tail = await parseJsonlTail(filePath, cached.lineNo);
+            const messages = [...cached.messages, ...tail.appended];
+            this.fileCache.set(filePath, {
+                lineNo: tail.lineNo,
+                messages,
+                size: st.size,
+            });
+            return messages;
+        }
+        const full = await parseJsonlFileFull(filePath);
+        this.fileCache.set(filePath, {
+            lineNo: full.lineNo,
+            messages: full.messages,
+            size: st.size,
+        });
+        return full.messages;
+    }
+    async emitHistoryForFileNow(filePath, replyAgentId) {
         const fileAgentId = basename(filePath, '.jsonl');
         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);
+            const messages = await this.loadMessagesForFile(filePath);
+            const rawLineNo = this.fileCache.get(filePath)?.lineNo ?? messages.length;
             this.mtimeByAgent.set(agentId, statSync(filePath).mtimeMs);
-            this.emit('agent:history', { agentId, messages, updatedAt: Date.now() });
+            this.emit('agent:jsonl:updated', {
+                agentId: fileAgentId,
+                messages,
+                totalMessages: rawLineNo,
+                updatedAt: Date.now(),
+            });
+            const replyIds = new Set([agentId]);
+            for (const [subId, meta] of this.subscribed) {
+                if (subId === fileAgentId)
+                    continue;
+                const subPath = resolveJsonlFilePath(this.projectsDir, subId, this.resolveOpts(meta.title));
+                if (subPath === filePath)
+                    replyIds.add(subId);
+            }
+            const hasSubscriber = [...replyIds].some((id) => this.subscribed.has(id));
+            if (!hasSubscriber)
+                return;
+            if (this.historyReplyInFlight.has(agentId) ||
+                this.historyReplyInFlight.has(fileAgentId) ||
+                [...replyIds].some((id) => this.historyReplyInFlight.has(id))) {
+                bridgePipelineLog({
+                    dir: 'internal',
+                    event: 'poll:agent:history:SKIP',
+                    agentId,
+                    detail: `inFlight file=${fileAgentId.slice(0, 8)}`,
+                });
+                return;
+            }
+            for (const replyId of replyIds) {
+                if (!this.subscribed.has(replyId))
+                    continue;
+                this.emit('agent:history', {
+                    agentId: replyId,
+                    messages,
+                    totalMessages: rawLineNo,
+                    updatedAt: Date.now(),
+                });
+            }
         }
         catch {
             /* skip */
@@ -159,16 +295,26 @@ export class JsonlIndex extends EventEmitter {
         return filePath.slice(0, idx);
     }
     async loadHistory(agentId, opts) {
-        const filePath = resolveJsonlFilePath(this.projectsDir, agentId, opts);
+        const filePath = resolveJsonlFilePath(this.projectsDir, agentId, {
+            ...this.resolveOpts(opts?.title),
+            ...opts,
+        });
         if (!filePath) {
             return { agentId, messages: [], totalMessages: 0 };
         }
-        const messages = await parseJsonlFile(filePath);
+        const messages = await this.loadMessagesForFile(filePath);
         const totalMessages = messages.length;
         const limit = opts?.limit;
-        const trimmed = limit && limit > 0 && messages.length > limit
-            ? messages.slice(-limit)
-            : messages;
+        const offset = Math.max(0, opts?.offset ?? 0);
+        let trimmed = messages;
+        if (limit && limit > 0) {
+            const end = offset > 0 ? -offset : undefined;
+            const start = -(offset + limit);
+            trimmed = messages.slice(start, end);
+        }
+        else if (offset > 0) {
+            trimmed = messages.slice(0, -offset);
+        }
         return { agentId, messages: trimmed, totalMessages };
     }
 }
@@ -285,54 +431,72 @@ function walkForAgent(dir, agentId, depth = 0) {
     }
     return null;
 }
-async function parseJsonlFile(filePath) {
+function parseJsonlLine(line, lineNo) {
+    if (!line.trim())
+        return null;
+    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);
+            }
+        }
+        if (row.role === 'user') {
+            const raw = rawParts.join('\n');
+            const images = canonicalizeImagePaths(parseUserImagePaths(raw));
+            const text = stripJsonlRedactionArtifacts(cleanUserText(parts.join('\n').trim()));
+            const hasImages = images.length > 0;
+            if ((!text || isNoiseChatText(text)) && !hasImages)
+                return null;
+            if (text && isNoiseChatText(text) && !hasImages)
+                return null;
+            return {
+                role: 'user',
+                text: text || (hasImages ? 'Изображение' : ''),
+                images: hasImages ? images : undefined,
+                ts: lineNo,
+            };
+        }
+        if (row.role === 'assistant') {
+            const filtered = filterAssistantJsonlParts(parts);
+            const text = filtered.join('\n').trim();
+            if (text)
+                return { role: 'assistant', text, ts: lineNo };
+        }
+    }
+    catch {
+        /* skip bad line */
+    }
+    return null;
+}
+async function parseJsonlFileFull(filePath) {
     const messages = [];
     const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
     let lineNo = 0;
     for await (const line of rl) {
         lineNo++;
-        if (!line.trim())
+        const m = parseJsonlLine(line, lineNo);
+        if (m)
+            messages.push(m);
+    }
+    return { lineNo, messages };
+}
+async function parseJsonlTail(filePath, afterLineNo) {
+    const appended = [];
+    const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+    let lineNo = 0;
+    for await (const line of rl) {
+        lineNo++;
+        if (lineNo <= afterLineNo)
             continue;
-        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);
-                }
-                // tool_use, tool_result — ignore
-            }
-            if (row.role === 'user') {
-                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') {
-                const filtered = filterAssistantJsonlParts(parts);
-                const text = filtered.join('\n').trim();
-                if (text)
-                    messages.push({ role: 'assistant', text, ts: lineNo });
-            }
-        }
-        catch {
-            /* skip bad line */
-        }
+        const m = parseJsonlLine(line, lineNo);
+        if (m)
+            appended.push(m);
     }
-    return messages;
+    return { lineNo, appended };
 }

package/bridge-runtime/dist/jsonl-live-debug.d.ts

@@ -0,0 +1,24 @@
+export type JsonlLiveRow = {
+    lineNo: number;
+    role: string;
+    textPreview: string;
+    textLen: number;
+    tools: string[];
+    /** Попадёт в ленту app после filter + collapse (отдельная строка до collapse). */
+    inLenta: boolean;
+    skipReason?: string;
+};
+export type JsonlLiveSnapshot = {
+    agentId: string;
+    filePath: string | null;
+    fileSize: number;
+    totalLines: number;
+    updatedAt: number;
+    rows: JsonlLiveRow[];
+};
+/** Read JSONL file rows for debug live view (`afterLine` exclusive, or tail when afterLine=0). */
+export declare function readJsonlLiveSnapshot(filePath: string, agentId: string, opts?: {
+    afterLine?: number;
+    tail?: number;
+    maxNew?: number;
+}): Promise<JsonlLiveSnapshot>;

package/bridge-runtime/dist/jsonl-live-debug.js

@@ -0,0 +1,175 @@
+import { createReadStream } from 'fs';
+import { statSync } from 'fs';
+import { createInterface } from 'readline';
+import { cleanUserText, filterAssistantJsonlParts, isAssistantReflectionText, isMeaningfulAssistantText, isNoiseChatText, parseUserImagePaths, stripJsonlRedactionArtifacts, } from './message-filter.js';
+import { canonicalizeImagePaths } from './media-path.js';
+function classifyJsonlLine(line, lineNo) {
+    if (!line.trim()) {
+        return {
+            lineNo,
+            role: '—',
+            textPreview: '',
+            textLen: 0,
+            tools: [],
+            inLenta: false,
+            skipReason: 'blank',
+        };
+    }
+    try {
+        const row = JSON.parse(line);
+        const role = row.role ?? '?';
+        const tools = [];
+        const parts = [];
+        const rawParts = [];
+        for (const c of row.message?.content ?? []) {
+            if (c.type === 'tool_use' && c.name)
+                tools.push(String(c.name));
+            if (c.type === 'text' && c.text) {
+                rawParts.push(c.text);
+                const t = cleanUserText(c.text);
+                if (t)
+                    parts.push(t);
+            }
+        }
+        const rawJoined = rawParts.join('\n').trim();
+        const preview = rawJoined.slice(0, 600);
+        if (role === 'user') {
+            const images = canonicalizeImagePaths(parseUserImagePaths(rawJoined));
+            const text = stripJsonlRedactionArtifacts(cleanUserText(parts.join('\n').trim()));
+            const hasImages = images.length > 0;
+            if ((!text || isNoiseChatText(text)) && !hasImages) {
+                return {
+                    lineNo,
+                    role,
+                    textPreview: preview || '(noise)',
+                    textLen: rawJoined.length,
+                    tools,
+                    inLenta: false,
+                    skipReason: 'user-noise',
+                };
+            }
+            return {
+                lineNo,
+                role,
+                textPreview: text || (hasImages ? '[images]' : preview),
+                textLen: rawJoined.length,
+                tools,
+                inLenta: true,
+            };
+        }
+        if (role === 'assistant') {
+            if (!parts.length && tools.length) {
+                return {
+                    lineNo,
+                    role,
+                    textPreview: preview || '[REDACTED]',
+                    textLen: rawJoined.length,
+                    tools,
+                    inLenta: false,
+                    skipReason: 'tool-only',
+                };
+            }
+            const filtered = filterAssistantJsonlParts(parts);
+            const text = filtered.join('\n').trim();
+            if (!text) {
+                let skipReason = 'empty-parts';
+                for (const p of parts) {
+                    if (isAssistantReflectionText(p))
+                        skipReason = 'reflection';
+                    else if (isNoiseChatText(p))
+                        skipReason = 'noise';
+                    else if (!isMeaningfulAssistantText(p))
+                        skipReason = 'not-meaningful';
+                }
+                return {
+                    lineNo,
+                    role,
+                    textPreview: preview || '[REDACTED]',
+                    textLen: rawJoined.length,
+                    tools,
+                    inLenta: false,
+                    skipReason,
+                };
+            }
+            return {
+                lineNo,
+                role,
+                textPreview: text.slice(0, 600),
+                textLen: rawJoined.length,
+                tools,
+                inLenta: true,
+            };
+        }
+        return {
+            lineNo,
+            role,
+            textPreview: preview,
+            textLen: rawJoined.length,
+            tools,
+            inLenta: false,
+            skipReason: 'unknown-role',
+        };
+    }
+    catch {
+        return {
+            lineNo,
+            role: '?',
+            textPreview: line.slice(0, 120),
+            textLen: line.length,
+            tools: [],
+            inLenta: false,
+            skipReason: 'json-error',
+        };
+    }
+}
+/** Read JSONL file rows for debug live view (`afterLine` exclusive, or tail when afterLine=0). */
+export async function readJsonlLiveSnapshot(filePath, agentId, opts) {
+    const afterLine = Math.max(0, opts?.afterLine ?? 0);
+    const tail = Math.min(500, Math.max(0, opts?.tail ?? 0));
+    const maxNew = Math.min(128, Math.max(1, opts?.maxNew ?? 64));
+    let fileSize = 0;
+    let totalLines = 0;
+    try {
+        fileSize = statSync(filePath).size;
+    }
+    catch {
+        return {
+            agentId,
+            filePath: null,
+            fileSize: 0,
+            totalLines: 0,
+            updatedAt: Date.now(),
+            rows: [],
+        };
+    }
+    const buffered = [];
+    const rows = [];
+    const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+    for await (const line of rl) {
+        totalLines++;
+        if (afterLine > 0) {
+            if (totalLines <= afterLine)
+                continue;
+            rows.push(classifyJsonlLine(line, totalLines));
+            continue;
+        }
+        buffered.push(classifyJsonlLine(line, totalLines));
+    }
+    if (afterLine === 0) {
+        if (tail > 0)
+            rows.push(...buffered.slice(-tail));
+        else
+            rows.push(...buffered.slice(-maxNew));
+    }
+    else if (rows.length > maxNew) {
+        rows.splice(0, rows.length - maxNew);
+    }
+    return {
+        agentId,
+        filePath,
+        fileSize,
+        totalLines,
+        updatedAt: Date.now(),
+        rows,
+    };
+}

package/bridge-runtime/dist/media-path.d.ts

@@ -1,5 +1,7 @@
 /** `vscode-file://` / `file://` → absolute path on disk (or http URL). */
 export declare function normalizeMediaRef(src: string): string | null;
+/** One path per file for merge/dedupe (JSONL absolute vs DOM vscode-file://). */
+export declare function canonicalizeImagePaths(paths: Iterable<string>): string[];
 /** Resolve query `path` from client (absolute path or vscode-file URL). */
 export declare function resolveMediaPathParam(rawPath: string): string | null;
 export declare function isAllowedMediaPath(filePath: string): boolean;

package/bridge-runtime/dist/media-path.js

@@ -21,6 +21,23 @@ export function normalizeMediaRef(src) {
         return path.normalize(fsPath);
     return null;
 }
+/** One path per file for merge/dedupe (JSONL absolute vs DOM vscode-file://). */
+export function canonicalizeImagePaths(paths) {
+    const out = [];
+    const seen = new Set();
+    for (const raw of paths) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        const canon = normalizeMediaRef(trimmed) ??
+            (path.isAbsolute(trimmed) ? path.normalize(trimmed) : trimmed);
+        if (seen.has(canon))
+            continue;
+        seen.add(canon);
+        out.push(canon);
+    }
+    return out;
+}
 /** Resolve query `path` from client (absolute path or vscode-file URL). */
 export function resolveMediaPathParam(rawPath) {
     const trimmed = rawPath.trim();

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

@@ -16,6 +16,8 @@ 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;
+/** Markdown / structured answer — must stay in chat lenta even if it mentions bridge symbols. */
+export declare function isUserFacingAssistantProse(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). */