cursorconnect 0.1.6 → 0.1.8

package/bridge-runtime/.env.example

@@ -3,17 +3,29 @@ 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 = DOM overlay until turn is in .jsonl.
+# 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
 # RELAY_TOKEN=same-as-relay-.env
 # RELAY_ROOM_ID=default
+# macOS: не давать Mac уснуть, пока bridge запущен (cursorconnect start). Выключить: KEEP_AWAKE=0
+# KEEP_AWAKE=0
+# Периодический ping relay upstream (NAT/idle). 0 = выкл.
+# RELAY_KEEPALIVE_MS=20000

package/bridge-runtime/connector-version.json

@@ -1 +1 @@
-{"cliVersion":"0.1.6","bundledAt":"2026-05-25T09:55:59Z"}
+{"cliVersion":"0.1.8","bundledAt":"2026-05-26T06:15:47Z"}

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

@@ -0,0 +1,35 @@
+import type { AgentsIndex, CursorState } 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 once per real generation session: agent must be stably working (≥3 DOM polls),
+ * then stably idle (≥2 polls). Opening a finished chat may flicker isWorking for 1 poll — ignored.
+ */
+export declare class AgentCompletionPush {
+    private emit;
+    private agentsIndex;
+    private prevWorking;
+    private workingPolls;
+    /** Agent had a real generation episode this bridge session (not open-chat flicker). */
+    private confirmedWorking;
+    private idlePolls;
+    private lastEmitAt;
+    private emittedThisSession;
+    /** ~3 × 400ms — ignore brief spinner when opening a finished chat. */
+    private static readonly WORKING_POLLS_REQUIRED;
+    /** ~2 × 400ms idle before push. */
+    private static readonly IDLE_POLLS_REQUIRED;
+    private static readonly MIN_EMIT_GAP_MS;
+    constructor(emit: AgentCompletionPushEmit, agentsIndex: () => AgentsIndex | null);
+    observe(state: CursorState): void;
+    private trackWorkingSessions;
+    private detectIdleCompletions;
+    private syncPrevWorking;
+    private tryEmit;
+}

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

@@ -0,0 +1,195 @@
+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, ' ');
+}
+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 'Чат';
+}
+/** Active + background sidebar tabs that show generation. */
+function snapshotWorkingAgents(state, agentsIndex) {
+    const map = new Map();
+    const activeId = state.activeComposerId;
+    const activeGenerating = !!state.agentWorking &&
+        !!activeId &&
+        isStableComposerId(activeId) &&
+        !agentPausedForInput(state, 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;
+        if (agentPausedForInput(state, id))
+            continue;
+        map.set(id, tab.title?.trim() || resolveAgentChatTitle(id, state, agentsIndex));
+    }
+    return map;
+}
+function agentPausedForInput(state, agentId) {
+    const isActive = state.activeComposerId === agentId;
+    if (!isActive)
+        return false;
+    return ((state.pendingApprovals?.length ?? 0) > 0 ||
+        !!state.pendingQuestionnaire ||
+        state.agentStatus === 'waiting_approval' ||
+        state.agentStatus === 'waiting_questionnaire');
+}
+function isStillWorkingWithTitle(title, now) {
+    const norm = normalizeTitle(title);
+    if (!norm)
+        return false;
+    for (const t of now.values()) {
+        if (normalizeTitle(t) === norm)
+            return true;
+    }
+    return false;
+}
+/**
+ * Push once per real generation session: agent must be stably working (≥3 DOM polls),
+ * then stably idle (≥2 polls). Opening a finished chat may flicker isWorking for 1 poll — ignored.
+ */
+export class AgentCompletionPush {
+    emit;
+    agentsIndex;
+    prevWorking = null;
+    workingPolls = new Map();
+    /** Agent had a real generation episode this bridge session (not open-chat flicker). */
+    confirmedWorking = new Set();
+    idlePolls = new Map();
+    lastEmitAt = new Map();
+    emittedThisSession = new Set();
+    /** ~3 × 400ms — ignore brief spinner when opening a finished chat. */
+    static WORKING_POLLS_REQUIRED = 3;
+    /** ~2 × 400ms idle before push. */
+    static IDLE_POLLS_REQUIRED = 2;
+    static MIN_EMIT_GAP_MS = 8_000;
+    constructor(emit, agentsIndex) {
+        this.emit = emit;
+        this.agentsIndex = agentsIndex;
+    }
+    observe(state) {
+        if (isSuppressed()) {
+            this.syncPrevWorking(state);
+            return;
+        }
+        const index = this.agentsIndex();
+        const now = snapshotWorkingAgents(state, index);
+        this.trackWorkingSessions(now);
+        this.detectIdleCompletions(now, state);
+    }
+    trackWorkingSessions(now) {
+        for (const id of now.keys()) {
+            const polls = (this.workingPolls.get(id) ?? 0) + 1;
+            this.workingPolls.set(id, polls);
+            if (polls >= AgentCompletionPush.WORKING_POLLS_REQUIRED && !this.confirmedWorking.has(id)) {
+                this.confirmedWorking.add(id);
+                this.emittedThisSession.delete(id);
+                this.idlePolls.delete(id);
+            }
+        }
+        for (const id of this.workingPolls.keys()) {
+            if (!now.has(id))
+                this.workingPolls.delete(id);
+        }
+    }
+    detectIdleCompletions(now, state) {
+        const prev = this.prevWorking;
+        if (prev === null) {
+            this.prevWorking = new Map(now);
+            return;
+        }
+        for (const [agentId] of prev) {
+            if (now.has(agentId)) {
+                this.idlePolls.delete(agentId);
+                continue;
+            }
+            if (!this.confirmedWorking.has(agentId))
+                continue;
+            const polls = (this.idlePolls.get(agentId) ?? 0) + 1;
+            this.idlePolls.set(agentId, polls);
+            if (polls < AgentCompletionPush.IDLE_POLLS_REQUIRED)
+                continue;
+            this.tryEmit(agentId, state);
+        }
+        for (const id of this.idlePolls.keys()) {
+            if (now.has(id))
+                this.idlePolls.delete(id);
+        }
+        this.prevWorking = new Map(now);
+    }
+    syncPrevWorking(state) {
+        this.prevWorking = snapshotWorkingAgents(state, this.agentsIndex());
+    }
+    tryEmit(agentId, state) {
+        if (agentPausedForInput(state, agentId))
+            return;
+        if (this.emittedThisSession.has(agentId))
+            return;
+        if (!this.confirmedWorking.has(agentId))
+            return;
+        const now = snapshotWorkingAgents(state, this.agentsIndex());
+        if (now.has(agentId))
+            return;
+        const title = normalizeTitle(resolveAgentChatTitle(agentId, state, this.agentsIndex())) || 'Чат';
+        if (isStillWorkingWithTitle(title, now))
+            return;
+        const last = this.lastEmitAt.get(agentId) ?? 0;
+        if (Date.now() - last < AgentCompletionPush.MIN_EMIT_GAP_MS)
+            return;
+        this.emit({
+            agentId,
+            chatTitle: title,
+            body: AGENT_COMPLETION_PUSH_BODY,
+        });
+        this.lastEmitAt.set(agentId, Date.now());
+        this.emittedThisSession.add(agentId);
+        this.confirmedWorking.delete(agentId);
+        this.idlePolls.delete(agentId);
+        this.workingPolls.delete(agentId);
+        console.log(`[agent-completion-push] → relay dom-idle agentId=${agentId.slice(0, 12)} title=${title.slice(0, 48)}`);
+    }
+}

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 overlay → `liveMessages` in `agent:messages` until JSONL has the same turn.
+ */
 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,103 @@
-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 overlay → `liveMessages` in `agent:messages` until JSONL has the same turn.
+ */
 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;
+        if (rows.length > 0 && prevRows > 24 && rows.length < prevRows - 12) {
+            return;
+        }
+        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[];