cursorconnect 0.1.5 → 0.1.7

package/bridge-runtime/.env.example

@@ -3,15 +3,23 @@ SERVER_HOST=127.0.0.1
 SERVER_PORT=3847
 POLL_INTERVAL_MS=400
 DEBOUNCE_MS=150
+# JSONL live lenta: poll subscribed (120ms), live watcher on subscribe (immediate), debounce off for live
+# JSONL_POLL_MS=120
+# JSONL_EMIT_DEBOUNCE_MS=0
+# JSONL_WRITE_STABILITY_MS=50
 WINDOW_POLL_INTERVAL_MS=8000
 WEBAPP_PASSWORD=
 # Leave empty to use ~/.cursor/projects
 # CURSOR_PROJECTS_DIR=
 LOG_LEVEL=info
+
+# Chat lenta: JSONL → agent:messages (liveMessages always []). DOM = state:patch (working, approve).
+# CHAT_HISTORY_JSONL=1 — extra socket agent:history on app (legacy).
+# CHAT_HISTORY_JSONL=1
 # Follow active Cursor window in CDP (1.5s poll). Set FOCUS_SYNC_ENABLED=0 to disable.
 # FOCUS_SYNC_INTERVAL_MS=1500
-# Voice → text in app (POST /api/transcribe, Whisper)
-OPENAI_API_KEY=
+# Voice → text only for local bridge without relay (prod: relay/.env OPENAI_API_KEY)
+# OPENAI_API_KEY=
 # OPENAI_TRANSCRIBE_MODEL=whisper-1
 # Remote relay (VPS): transparent Socket.io forward; processing stays on this Mac
 # RELAY_URL=https://your-domain.example

package/bridge-runtime/connector-version.json

@@ -0,0 +1 @@
+{"cliVersion":"0.1.7","bundledAt":"2026-05-25T18:20:35Z"}

package/bridge-runtime/dist/agent-completion-push.d.ts

@@ -0,0 +1,42 @@
+import type { AgentsIndex, CursorState, HistoryMessage } from './types.js';
+export declare const AGENT_COMPLETION_PUSH_BODY = "\u0410\u0433\u0435\u043D\u0442 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B \u0440\u0430\u0431\u043E\u0442\u0443";
+export declare function suppressAgentCompletionPush(ms?: number): void;
+export interface AgentCompletionPushPayload {
+    agentId: string;
+    chatTitle: string;
+    body: string;
+}
+export type AgentCompletionPushEmit = (payload: AgentCompletionPushPayload) => void;
+/**
+ * Push when a new assistant row lands in JSONL for the current/recent task.
+ * If JSONL flushes while DOM still shows "working", retry when DOM goes idle.
+ */
+export declare class AgentCompletionPush {
+    private emit;
+    private agentsIndex;
+    private getState;
+    /** Last seen assistant line id in JSONL (line number / ts). */
+    private lastJsonlAssistantKey;
+    /** Agents that were generating on previous DOM poll. */
+    private prevWorking;
+    private lastEmitAt;
+    /** JSONL had a new assistant line while DOM was still working — emit after idle. */
+    private pendingAfterIdle;
+    private pendingDeferSince;
+    private deferTimers;
+    private lastJsonlMessages;
+    private static readonly MIN_EMIT_GAP_MS;
+    /** DOM can lie "working" after JSONL finished — emit anyway after this. */
+    private static readonly MAX_DEFER_MS;
+    constructor(emit: AgentCompletionPushEmit, agentsIndex: () => AgentsIndex | null, getState: () => CursorState);
+    /** Sync working snapshot; flush pending push when a task leaves DOM "working". */
+    observe(state: CursorState): void;
+    /**
+     * JSONL file updated — push if a new assistant message was appended for this task
+     * and DOM no longer shows generation for that composer.
+     */
+    onJsonlUpdated(agentId: string, messages: HistoryMessage[], state: CursorState): void;
+    private scheduleDeferTimeout;
+    private clearDeferTimer;
+    private tryEmit;
+}

package/bridge-runtime/dist/agent-completion-push.js

@@ -0,0 +1,220 @@
+export const AGENT_COMPLETION_PUSH_BODY = 'Агент завершил работу';
+let suppressUntil = 0;
+export function suppressAgentCompletionPush(ms = 6000) {
+    suppressUntil = Date.now() + ms;
+}
+function isSuppressed() {
+    return Date.now() < suppressUntil;
+}
+function normalizeTitle(title) {
+    return title.trim().replace(/\s+/g, ' ');
+}
+/** Ephemeral sidebar ids (tab-0) must not drive push — composerId can appear next poll. */
+function isStableComposerId(id) {
+    if (!id?.trim())
+        return false;
+    const t = id.trim();
+    if (t.startsWith('tab-'))
+        return false;
+    return t.length >= 8;
+}
+function titleForComposerId(agentId, state) {
+    const activeTitle = state.activeChatTitle?.trim();
+    if (state.activeComposerId === agentId && activeTitle)
+        return activeTitle;
+    for (const tab of state.tabs) {
+        const id = tab.composerId ?? tab.id;
+        if (id === agentId)
+            return tab.title?.trim() || undefined;
+    }
+    for (const repo of state.sidebarRepos ?? []) {
+        for (const agent of repo.agents) {
+            if (agent.id === agentId)
+                return agent.title?.trim() || undefined;
+        }
+    }
+    return undefined;
+}
+function resolveAgentChatTitle(agentId, state, agentsIndex) {
+    const fromState = titleForComposerId(agentId, state);
+    if (fromState)
+        return fromState;
+    for (const repo of agentsIndex?.repos ?? []) {
+        for (const agent of repo.agents) {
+            if (agent.id === agentId)
+                return agent.title?.trim() || 'Чат';
+        }
+    }
+    return 'Чат';
+}
+/**
+ * Working agents for correlating JSONL flush with the task that was running.
+ * Sidebar: stable composerId only (no tab-N flicker).
+ */
+function snapshotWorkingAgents(state, agentsIndex) {
+    const map = new Map();
+    const activeId = state.activeComposerId;
+    const activeGenerating = state.agentStatus === 'working' &&
+        !!activeId &&
+        isStableComposerId(activeId);
+    if (activeGenerating && activeId) {
+        map.set(activeId, resolveAgentChatTitle(activeId, state, agentsIndex));
+    }
+    for (const tab of state.tabs) {
+        if (!tab.isWorking)
+            continue;
+        const id = tab.composerId?.trim();
+        if (!id || !isStableComposerId(id))
+            continue;
+        map.set(id, tab.title?.trim() || resolveAgentChatTitle(id, state, agentsIndex));
+    }
+    return map;
+}
+function agentPausedForInput(state) {
+    return ((state.pendingApprovals?.length ?? 0) > 0 ||
+        !!state.pendingQuestionnaire ||
+        state.agentStatus === 'waiting_approval' ||
+        state.agentStatus === 'waiting_questionnaire');
+}
+function lastAssistantLineKey(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role === 'assistant')
+            return m.ts ?? i;
+    }
+    return 0;
+}
+/**
+ * Push when a new assistant row lands in JSONL for the current/recent task.
+ * If JSONL flushes while DOM still shows "working", retry when DOM goes idle.
+ */
+export class AgentCompletionPush {
+    emit;
+    agentsIndex;
+    getState;
+    /** Last seen assistant line id in JSONL (line number / ts). */
+    lastJsonlAssistantKey = new Map();
+    /** Agents that were generating on previous DOM poll. */
+    prevWorking = new Map();
+    lastEmitAt = new Map();
+    /** JSONL had a new assistant line while DOM was still working — emit after idle. */
+    pendingAfterIdle = new Set();
+    pendingDeferSince = new Map();
+    deferTimers = new Map();
+    lastJsonlMessages = new Map();
+    static MIN_EMIT_GAP_MS = 45_000;
+    /** DOM can lie "working" after JSONL finished — emit anyway after this. */
+    static MAX_DEFER_MS = 12_000;
+    constructor(emit, agentsIndex, getState) {
+        this.emit = emit;
+        this.agentsIndex = agentsIndex;
+        this.getState = getState;
+    }
+    /** Sync working snapshot; flush pending push when a task leaves DOM "working". */
+    observe(state) {
+        const index = this.agentsIndex();
+        if (isSuppressed() || agentPausedForInput(state)) {
+            this.prevWorking = snapshotWorkingAgents(state, index);
+            return;
+        }
+        const nowWorking = snapshotWorkingAgents(state, index);
+        for (const agentId of this.pendingAfterIdle) {
+            if (nowWorking.has(agentId))
+                continue;
+            const messages = this.lastJsonlMessages.get(agentId);
+            if (messages?.length) {
+                this.tryEmit(agentId, messages, state, 'dom-idle');
+            }
+        }
+        this.prevWorking = nowWorking;
+    }
+    /**
+     * JSONL file updated — push if a new assistant message was appended for this task
+     * and DOM no longer shows generation for that composer.
+     */
+    onJsonlUpdated(agentId, messages, state) {
+        if (isSuppressed() || agentPausedForInput(state))
+            return;
+        if (!isStableComposerId(agentId))
+            return;
+        const lineKey = lastAssistantLineKey(messages);
+        if (!lineKey)
+            return;
+        const prevKey = this.lastJsonlAssistantKey.get(agentId);
+        if (prevKey === undefined) {
+            this.lastJsonlAssistantKey.set(agentId, lineKey);
+            this.lastJsonlMessages.set(agentId, messages);
+            return;
+        }
+        if (lineKey <= prevKey)
+            return;
+        this.lastJsonlAssistantKey.set(agentId, lineKey);
+        this.lastJsonlMessages.set(agentId, messages);
+        const nowWorking = snapshotWorkingAgents(state, this.agentsIndex());
+        if (nowWorking.has(agentId)) {
+            this.pendingAfterIdle.add(agentId);
+            if (!this.pendingDeferSince.has(agentId)) {
+                this.pendingDeferSince.set(agentId, Date.now());
+            }
+            this.scheduleDeferTimeout(agentId);
+            console.log(`[agent-completion-push] defer agentId=${agentId.slice(0, 12)} line=${lineKey} (dom still working)`);
+            return;
+        }
+        this.clearDeferTimer(agentId);
+        this.pendingDeferSince.delete(agentId);
+        this.tryEmit(agentId, messages, state, 'jsonl');
+    }
+    scheduleDeferTimeout(agentId) {
+        if (this.deferTimers.has(agentId))
+            return;
+        const timer = setTimeout(() => {
+            this.deferTimers.delete(agentId);
+            const since = this.pendingDeferSince.get(agentId) ?? 0;
+            if (!this.pendingAfterIdle.has(agentId))
+                return;
+            if (Date.now() - since < AgentCompletionPush.MAX_DEFER_MS - 100)
+                return;
+            const messages = this.lastJsonlMessages.get(agentId);
+            if (!messages?.length)
+                return;
+            console.log(`[agent-completion-push] defer timeout agentId=${agentId.slice(0, 12)} (dom still working, jsonl done)`);
+            this.tryEmit(agentId, messages, this.getState(), 'defer-timeout');
+        }, AgentCompletionPush.MAX_DEFER_MS);
+        this.deferTimers.set(agentId, timer);
+    }
+    clearDeferTimer(agentId) {
+        const t = this.deferTimers.get(agentId);
+        if (t)
+            clearTimeout(t);
+        this.deferTimers.delete(agentId);
+    }
+    tryEmit(agentId, messages, state, reason) {
+        const lineKey = lastAssistantLineKey(messages);
+        if (!lineKey)
+            return;
+        const nowWorking = snapshotWorkingAgents(state, this.agentsIndex());
+        if (reason !== 'defer-timeout' && nowWorking.has(agentId))
+            return;
+        const isCurrentTask = state.activeComposerId === agentId ||
+            this.prevWorking.has(agentId) ||
+            this.pendingAfterIdle.has(agentId);
+        if (!isCurrentTask)
+            return;
+        const last = this.lastEmitAt.get(agentId) ?? 0;
+        if (Date.now() - last < AgentCompletionPush.MIN_EMIT_GAP_MS)
+            return;
+        const chatTitle = normalizeTitle(this.prevWorking.get(agentId) ??
+            resolveAgentChatTitle(agentId, state, this.agentsIndex())) || 'Чат';
+        this.emit({
+            agentId,
+            chatTitle,
+            body: AGENT_COMPLETION_PUSH_BODY,
+        });
+        this.lastEmitAt.set(agentId, Date.now());
+        this.pendingAfterIdle.delete(agentId);
+        this.pendingDeferSince.delete(agentId);
+        this.clearDeferTimer(agentId);
+        this.prevWorking.delete(agentId);
+        console.log(`[agent-completion-push] → relay reason=${reason} agentId=${agentId.slice(0, 12)} title=${chatTitle.slice(0, 48)} line=${lineKey}`);
+    }
+}

package/bridge-runtime/dist/agent-title-match.d.ts

@@ -6,12 +6,13 @@ export declare function findAgentById(jsonl: AgentsIndex, agentId: string): Agen
 /** Best JSONL agent for a Cursor sidebar row (generated title vs first user message). */
 export declare function matchJsonlAgentForSidebarTitle(rowTitle: string, jsonl: AgentsIndex, composerIdByTitle?: Record<string, string>): AgentSummary | undefined;
 export declare function isSyntheticAgentId(agentId: string): boolean;
-/** Map app/relay agentId (+ optional sidebar title) to an on-disk JSONL id. */
-export declare function resolveJsonlAgentId(projectsDir: string, agentId: string, opts?: {
-    title?: string;
-    composerIdByTitle?: Record<string, string>;
-}): string;
-export declare function resolveJsonlFilePath(projectsDir: string, agentId: string, opts?: {
+export type ResolveJsonlOpts = {
     title?: string;
     composerIdByTitle?: Record<string, string>;
-}): string | null;
+    /** Cursor's active composer UUID — binds `sidebar-N` to the open chat file. */
+    activeComposerId?: string;
+    activeTabTitle?: string;
+};
+/** Map app/relay agentId (+ optional sidebar title) to an on-disk JSONL id. */
+export declare function resolveJsonlAgentId(projectsDir: string, agentId: string, opts?: ResolveJsonlOpts): string;
+export declare function resolveJsonlFilePath(projectsDir: string, agentId: string, opts?: ResolveJsonlOpts): string | null;

package/bridge-runtime/dist/agent-title-match.js

@@ -1,5 +1,6 @@
 import { basename, join } from 'path';
 import { existsSync, readdirSync, readFileSync } from 'fs';
+import { normalizeComposerTitle, titlesAlign } from './composer-title-index.js';
 export function normalizeAgentTitle(title) {
     return title
         .trim()
@@ -182,10 +183,19 @@ export function resolveJsonlAgentId(projectsDir, agentId, opts) {
     const title = opts?.title?.trim();
     const map = opts?.composerIdByTitle;
     if (title && map) {
-        const mapped = map[normalizeAgentTitle(title)];
+        const mapped = map[normalizeComposerTitle(title)] ?? map[normalizeAgentTitle(title)];
         if (mapped && findJsonlByAgentId(projectsDir, mapped))
             return mapped;
     }
+    const activeComposerId = opts?.activeComposerId?.trim();
+    if (isSyntheticAgentId(agentId) &&
+        activeComposerId &&
+        UUID_RE.test(activeComposerId) &&
+        findJsonlByAgentId(projectsDir, activeComposerId)) {
+        const tabT = opts?.activeTabTitle?.trim();
+        if (!title || !tabT || titlesAlign(title, tabT))
+            return activeComposerId;
+    }
     if (title) {
         let best;
         for (const row of collectJsonlAgents(projectsDir)) {

package/bridge-runtime/dist/chat-display-store.d.ts

@@ -1,13 +1,25 @@
 import type { ChatMessage, HistoryMessage } from './types.js';
-/** Per-agent prepared history + merge with live DOM for subscribed chat. */
+/**
+ * Chat UI store: JSONL baseline for `agent:messages` (client lenta).
+ * DOM transcript kept for debug snapshot only — not sent as liveMessages.
+ */
 export declare class ChatDisplayStore {
-    private historyByAgent;
+    private readonly domTranscript;
+    private readonly jsonlBaseline;
+    /** Raw JSONL row count per agent — incremental display merge during streaming. */
+    private readonly jsonlRowCount;
     clearAgent(agentId: string): void;
-    /** JSONL / HTTP / socket history — returns display-ready messages. */
-    applyHistory(agentId: string, rows: HistoryMessage[], opts?: {
-        mergeWithCache?: boolean;
-    }): ChatMessage[];
-    getHistory(agentId: string): ChatMessage[];
-    /** Raw DOM extract for active composer → merged display list when history exists. */
-    mergeLiveForAgent(agentId: string, rawDom: ChatMessage[]): ChatMessage[];
+    getJsonlHistory(agentId: string): ChatMessage[];
+    getDomLive(agentId: string): ChatMessage[];
+    /** Reload JSONL; prune DOM rows now covered by archive. */
+    setJsonlBaseline(agentId: string, rows: HistoryMessage[]): void;
+    /** Append JSONL rows during live stream; returns new/updated bubbles for socket `append` emit. */
+    appendJsonlRows(agentId: string, deltaRows: HistoryMessage[]): ChatMessage[];
+    /** Ingest DOM extract; overlay keeps only rows not in JSONL. */
+    mergeLiveForAgent(agentId: string, rawDom: ChatMessage[]): void;
+    /** Debug / snapshot: combined view. */
+    getDisplayMessages(agentId: string): ChatMessage[];
+    getDomTranscript(agentId: string): ChatMessage[];
+    private domOverlayOnly;
+    private pruneDomOverlay;
 }

package/bridge-runtime/dist/chat-display-store.js

@@ -1,29 +1,100 @@
-import { filterClientDisplayList, historyRowsToChat, mergeDomWithHistory, mergeHistoryTail, prepareChatMessagesForDisplay, } from './chat-display.js';
-/** Per-agent prepared history + merge with live DOM for subscribed chat. */
+import { filterClientDisplayList, historyRowsToChat, mergeHistoryTail, messagesEquivalent, prepareChatMessagesForDisplay, } from './chat-display.js';
+import { DomTranscriptStore } from './dom-transcript-store.js';
+/**
+ * Chat UI store: JSONL baseline for `agent:messages` (client lenta).
+ * DOM transcript kept for debug snapshot only — not sent as liveMessages.
+ */
 export class ChatDisplayStore {
-    historyByAgent = new Map();
+    domTranscript = new DomTranscriptStore();
+    jsonlBaseline = new Map();
+    /** Raw JSONL row count per agent — incremental display merge during streaming. */
+    jsonlRowCount = new Map();
     clearAgent(agentId) {
-        this.historyByAgent.delete(agentId);
-    }
-    /** JSONL / HTTP / socket history — returns display-ready messages. */
-    applyHistory(agentId, rows, opts) {
-        const incoming = prepareChatMessagesForDisplay(historyRowsToChat(rows));
-        const prev = this.historyByAgent.get(agentId) ?? [];
-        const merged = opts?.mergeWithCache && prev.length
-            ? mergeHistoryTail(prev, incoming)
-            : incoming;
-        const out = filterClientDisplayList(merged);
-        this.historyByAgent.set(agentId, out);
-        return out;
-    }
-    getHistory(agentId) {
-        return this.historyByAgent.get(agentId) ?? [];
-    }
-    /** Raw DOM extract for active composer → merged display list when history exists. */
+        this.domTranscript.clear(agentId);
+        this.jsonlBaseline.delete(agentId);
+        this.jsonlRowCount.delete(agentId);
+    }
+    getJsonlHistory(agentId) {
+        return filterClientDisplayList(this.jsonlBaseline.get(agentId) ?? []);
+    }
+    getDomLive(agentId) {
+        const history = this.jsonlBaseline.get(agentId) ?? [];
+        return filterClientDisplayList(this.domOverlayOnly(agentId, history));
+    }
+    /** Reload JSONL; prune DOM rows now covered by archive. */
+    setJsonlBaseline(agentId, rows) {
+        const prevRows = this.jsonlRowCount.get(agentId) ?? 0;
+        const prev = this.jsonlBaseline.get(agentId) ?? [];
+        let prepared;
+        if (rows.length > prevRows && prevRows > 0 && prev.length && rows.length - prevRows <= 128) {
+            const delta = rows.slice(prevRows);
+            const deltaChat = prepareChatMessagesForDisplay(historyRowsToChat(delta));
+            prepared = mergeHistoryTail(prev, deltaChat);
+        }
+        else {
+            prepared = rows.length
+                ? prepareChatMessagesForDisplay(historyRowsToChat(rows))
+                : [];
+        }
+        this.jsonlRowCount.set(agentId, rows.length);
+        this.jsonlBaseline.set(agentId, prepared);
+        this.pruneDomOverlay(agentId);
+    }
+    /** Append JSONL rows during live stream; returns new/updated bubbles for socket `append` emit. */
+    appendJsonlRows(agentId, deltaRows) {
+        if (!deltaRows.length)
+            return [];
+        const prev = this.jsonlBaseline.get(agentId) ?? [];
+        const prevLen = prev.length;
+        const deltaChat = prepareChatMessagesForDisplay(historyRowsToChat(deltaRows));
+        const prepared = mergeHistoryTail(prev, deltaChat);
+        this.jsonlRowCount.set(agentId, (this.jsonlRowCount.get(agentId) ?? 0) + deltaRows.length);
+        this.jsonlBaseline.set(agentId, prepared);
+        this.pruneDomOverlay(agentId);
+        if (prepared.length > prevLen)
+            return prepared.slice(prevLen);
+        if (prepared.length && prevLen) {
+            const last = prepared[prepared.length - 1];
+            const prevLast = prev[prevLen - 1];
+            if (prevLast && last.id === prevLast.id && last.text !== prevLast.text)
+                return [last];
+            if (prevLast &&
+                last.role === prevLast.role &&
+                (last.text?.length ?? 0) > (prevLast.text?.length ?? 0) &&
+                last.text?.includes((prevLast.text ?? '').slice(0, 24))) {
+                return [last];
+            }
+        }
+        if (!prevLen && prepared.length)
+            return prepared;
+        return deltaChat.length ? deltaChat : [];
+    }
+    /** Ingest DOM extract; overlay keeps only rows not in JSONL. */
     mergeLiveForAgent(agentId, rawDom) {
         const live = prepareChatMessagesForDisplay(rawDom);
-        const hist = this.historyByAgent.get(agentId) ?? [];
-        const merged = hist.length ? mergeDomWithHistory(hist, live) : live;
-        return filterClientDisplayList(merged);
+        if (live.length)
+            this.domTranscript.ingest(agentId, live);
+        this.pruneDomOverlay(agentId);
+    }
+    /** Debug / snapshot: combined view. */
+    getDisplayMessages(agentId) {
+        return [...this.getJsonlHistory(agentId), ...this.getDomLive(agentId)];
+    }
+    getDomTranscript(agentId) {
+        return this.getDisplayMessages(agentId);
+    }
+    domOverlayOnly(agentId, history) {
+        const dom = this.domTranscript.list(agentId);
+        if (!dom.length)
+            return [];
+        if (!history.length)
+            return dom;
+        return dom.filter((d) => !history.some((h) => messagesEquivalent(h, d)));
+    }
+    pruneDomOverlay(agentId) {
+        const history = this.jsonlBaseline.get(agentId) ?? [];
+        if (!history.length)
+            return;
+        this.domTranscript.pruneCoveredBy(agentId, history);
     }
 }

package/bridge-runtime/dist/chat-display.d.ts

@@ -2,6 +2,8 @@ import type { ChatMessage, HistoryMessage } from './types.js';
 export declare function compareUserText(text: string): string;
 export declare function userTextsEquivalent(ta: string, tb: string): boolean;
 export declare function userMessagesEquivalent(a: ChatMessage, b: ChatMessage): boolean;
+export declare function messagesEquivalent(a: ChatMessage, b: ChatMessage): boolean;
+export declare function pickPreferredMessage(prev: ChatMessage, next: ChatMessage, preferNext: boolean): ChatMessage;
 export declare function sortMessagesChronologically(messages: ChatMessage[]): ChatMessage[];
 export declare function prepareChatMessagesForDisplay(messages: ChatMessage[]): ChatMessage[];
 export declare function mergeHistoryTail(prev: ChatMessage[], incoming: ChatMessage[]): ChatMessage[];