cursorconnect 0.1.7 → 0.1.9

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

@@ -9,6 +9,11 @@ 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;
+/** Paused for background shell — not active generation (no list spinner / agentWorking). */
+export declare function isPassiveBackgroundShellState(state: {
+    agentStatus?: string;
+    agentWorking?: boolean;
+}): 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 */

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

@@ -22,6 +22,10 @@ export function matchBackgroundWorkStatusText(text) {
 export function isBackgroundWorkStatusText(text) {
     return matchBackgroundWorkStatusText(text) !== undefined;
 }
+/** Paused for background shell — not active generation (no list spinner / agentWorking). */
+export function isPassiveBackgroundShellState(state) {
+    return (state.agentStatus === AGENT_STATUS_BACKGROUND_SHELL && state.agentWorking !== true);
+}
 /** Chat line that is only passive-work status (not prose mentioning it). */
 export function isPassiveStatusChatLine(text) {
     const t = text.trim().replace(/\s+/g, ' ');

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

@@ -5,9 +5,12 @@ export declare class RelayUpstream {
     private onClientEvent;
     private onConnect?;
     private socket;
+    private keepaliveTimer;
     constructor(config: ServerConfig, onClientEvent: UpstreamCommandHandler, onConnect?: (() => void) | undefined);
     private registerPairing;
     connect(): void;
+    private startKeepalive;
+    private stopKeepalive;
     emit(event: string, ...args: unknown[]): void;
     get connected(): boolean;
     private handleHttpProxy;

package/bridge-runtime/dist/relay-upstream.js

@@ -14,6 +14,7 @@ export class RelayUpstream {
     onClientEvent;
     onConnect;
     socket = null;
+    keepaliveTimer = null;
     constructor(config, onClientEvent, onConnect) {
         this.config = config;
         this.onClientEvent = onClientEvent;
@@ -85,6 +86,26 @@ export class RelayUpstream {
         this.socket.on('relay:http', (req) => {
             void this.handleHttpProxy(req);
         });
+        this.startKeepalive();
+    }
+    startKeepalive() {
+        this.stopKeepalive();
+        const ms = this.config.relayKeepaliveMs;
+        if (!this.config.relayUrl || ms <= 0)
+            return;
+        this.keepaliveTimer = setInterval(() => {
+            if (!this.socket?.connected)
+                return;
+            this.socket.emit('relay:connector-ping', {
+                roomId: this.config.relayRoomId,
+                ts: Date.now(),
+            });
+        }, ms);
+    }
+    stopKeepalive() {
+        if (this.keepaliveTimer)
+            clearInterval(this.keepaliveTimer);
+        this.keepaliveTimer = null;
     }
     emit(event, ...args) {
         if (this.socket?.connected)

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

@@ -28,19 +28,53 @@ export declare class Relay {
     private readonly chatDisplay;
     /** Raw JSONL row count last sent per agent (live `append` emits). */
     private readonly lastEmittedJsonlRows;
+    /** Last display tail pushed to app — re-emit when user/assistant tail changes. */
+    private readonly lastEmittedLentaSig;
+    /** Display bubble count last sent — block regression 214→74 style wipes on phone. */
+    private readonly lastEmittedHistLen;
+    private readonly lentaPendingSince;
+    private static readonly LENTA_PENDING_FORCE_MS;
+    /** Socket `agent:messages` coalesce — store ingest is immediate (see ingestDomOverlayFromState). */
+    private static readonly DOM_OVERLAY_EMIT_MS;
+    private domOverlayTimer;
+    private cachedLentaPendingByAgent;
     constructor(config: ServerConfig, stateManager: StateManager, commandExecutor: CommandExecutor, cdpBridge: CDPBridge, jsonlIndex: JsonlIndex, messageDebugStore: MessageDebugStore, domExtractor: DOMExtractor);
     private emitAgentCompletedPush;
     private flushPendingPushPayloads;
     private observeAgentCompletionForPush;
+    private requestAgentCompletionContentSync;
     listen(): Promise<void>;
     private get authEnabled();
+    private lentaAgentIds;
     /** Read-only view of in-memory bridge state (no writes to stores). */
     private readOnlyChatSnapshot;
+    private buildLentaDebugReport;
     /** Push JSONL file updates to every subscribed route id (e.g. sidebar-0) for that composer. */
     private syncJsonlToSubscribedAgents;
-    /** Live JSONL: push display deltas to app; `totalMessages` = raw `.jsonl` line count. */
+    /** JSONL baseline + DOM tail (`liveMessages`); `messages` = append-only compose. */
+    private lentaSnapshot;
+    private emitLentaForAgent;
+    private lentaTailSignature;
+    /** Live JSONL → `agent:messages` for subscribed chats (phone lenta). */
     private emitJsonlLiveForAgent;
-    /** Client lenta: JSONL only (`liveMessages` always empty). DOM stays in debug snapshot. */
+    /** Ingest CDP viewport into ChatDisplayStore — no debounce (debug + compose). */
+    private ingestDomOverlayFromState;
+    /** Push lenta with DOM live to clients while generation is in flight. */
+    private emitDomLiveWhileGenerating;
+    private syncGeneratingFlags;
+    /** Push composed lenta to subscribed clients (debounced). */
+    private emitDomOverlaySocketForSubscribers;
+    /** While generating, push overlay growth without waiting for emit debounce tail. */
+    private maybeEmitDomOverlayLeading;
+    private applyDomOverlayFromState;
+    private scheduleDomOverlayEmit;
+    /**
+     * Agent ids that should receive DOM ingest: active Cursor composer + synced subscriptions.
+     * Store must update even without phone subscribe (debug/lenta, later subscribe).
+     */
+    private resolveDomOverlayAgentIds;
+    private writeLentaCapture;
+    private resolveHistoryOpts;
     private agentMessagesSnapshot;
     private checkMediaAuth;
     private setupHttp;
@@ -49,9 +83,17 @@ export declare class Relay {
     private historySeqByAgent;
     private nextHistorySeq;
     private emitAgentMessages;
-    /** DOM messages in state:patch — debug/UI chrome only; chat lenta is JSONL via agent:messages. */
     private prepareStateMessages;
     private withDisplayState;
+    private buildLentaPendingByAgent;
+    private refreshLentaPendingCache;
+    private withRelayState;
+    private refreshLentaPendingPatch;
+    private noteLentaDelivery;
+    /** Push `agent:messages` when store is ahead of last emit (subscribed + synced). */
+    private flushLentaDelivery;
+    private flushPendingLentaForSubscribers;
+    private maybeForceStaleLentaDelivery;
     private wireEvents;
     private emitAgentsIndex;
     private refreshAgentsIndex;
@@ -63,6 +105,8 @@ export declare class Relay {
     private runCommand;
     private runAgentsHistory;
     private runAgentsSubscribe;
+    /** Load JSONL into store when DOM ingest runs but baseline empty (e.g. after bridge restart). */
+    private ensureJsonlBaselineForAgent;
     /** Открытие чата: JSONL baseline + focus/scroll (DOM poll только для state: working/approve). */
     private refreshDomChatOnSubscribe;
     private runAgentsUnsubscribe;