Skip to content

Automate browser based workflows with AI

SKY-10320: Keep local CDP debugger on live browser (#6297)

Andrew Neilson75799a06b173
diff --git a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.test.ts b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.test.ts
new file mode 100644
index 000000000..6b420856a
--- /dev/null
+++ b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+
+import {
+ isTerminalStreamStatus,
+ shouldReconnectStream,
+} from "./BrowserSessionStream.utils";
+
+describe("isTerminalStreamStatus", () => {
+ it("treats missing sessions as terminal stream statuses", () => {
+ expect(isTerminalStreamStatus("not_found")).toBe(true);
+ expect(isTerminalStreamStatus("running")).toBe(false);
+ });
+});
+
+describe("shouldReconnectStream", () => {
+ it("reconnects non-terminal stream closes below the attempt limit", () => {
+ expect(
+ shouldReconnectStream({
+ closeCode: 1006,
+ closeReason: "",
+ terminalStatusSeen: false,
+ reconnectAttempts: 0,
+ }),
+ ).toBe(true);
+ });
+
+ it("does not reconnect terminal, VNC fallback, normal, or exhausted stream closes", () => {
+ expect(
+ shouldReconnectStream({
+ closeCode: 1000,
+ closeReason: "",
+ terminalStatusSeen: true,
+ reconnectAttempts: 0,
+ }),
+ ).toBe(false);
+ expect(
+ shouldReconnectStream({
+ closeCode: 1000,
+ closeReason: "",
+ terminalStatusSeen: false,
+ reconnectAttempts: 0,
+ }),
+ ).toBe(false);
+ expect(
+ shouldReconnectStream({
+ closeCode: 4001,
+ closeReason: "use-vnc-streaming",
+ terminalStatusSeen: false,
+ reconnectAttempts: 0,
+ }),
+ ).toBe(false);
+ expect(
+ shouldReconnectStream({
+ closeCode: 1006,
+ closeReason: "",
+ terminalStatusSeen: false,
+ reconnectAttempts: 20,
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx
index bfbb84b1c..58bb9e5b6 100644
--- a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx
+++ b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx
@@ -7,6 +7,12 @@ import {
StreamStatusPanel,
type StreamDiagnostic,
} from "@/routes/streaming/StreamDiagnostics";
+import {
+ STREAM_MAX_RECONNECT_ATTEMPTS,
+ STREAM_RECONNECT_DELAY_MS,
+ isTerminalStreamStatus,
+ shouldReconnectStream,
+} from "./BrowserSessionStream.utils";
type StreamMessage = {
browser_session_id?: string;
@@ -24,6 +30,14 @@ const STARTING_DIAGNOSTIC: StreamDiagnostic = {
"Opening the stream WebSocket and waiting for the first browser frame.",
};
+function diagnosticForReconnectExhausted(): StreamDiagnostic {
+ return {
+ title: "Stream connection dropped",
+ detail: "The browser stream disconnected and could not reconnect.",
+ hint: "Refresh the editor or create a new browser session.",
+ };
+}
+
function diagnosticForStatus(status: string): StreamDiagnostic {
switch (status) {
case "not_found":
@@ -100,6 +114,9 @@ function BrowserSessionStream({
const socketRef = useRef<WebSocket | null>(null);
const hasFrameRef = useRef(false);
+ const reconnectAttemptsRef = useRef(0);
+ const terminalStatusSeenRef = useRef(false);
+ const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
const inputWsUrl = interactive
? `${newWssBaseUrl}/stream/cdp_input/browser_session/${browserSessionId}`
@@ -127,8 +144,17 @@ function BrowserSessionStream({
setCurrentUrl("");
setDiagnostic(STARTING_DIAGNOSTIC);
hasFrameRef.current = false;
+ reconnectAttemptsRef.current = 0;
+ terminalStatusSeenRef.current = false;
- async function run() {
+ const clearReconnectTimer = () => {
+ if (reconnectTimerRef.current) {
+ clearTimeout(reconnectTimerRef.current);
+ reconnectTimerRef.current = null;
+ }
+ };
+
+ async function connect() {
const credentialParam = await getCredentialParam(credentialGetter);
if (cancelled) {
return;
@@ -153,6 +179,7 @@ function BrowserSessionStream({
const message: StreamMessage = JSON.parse(event.data);
if (message.screenshot) {
hasFrameRef.current = true;
+ reconnectAttemptsRef.current = 0;
setStreamImgSrc(message.screenshot);
}
if (message.format) {
@@ -170,11 +197,8 @@ function BrowserSessionStream({
if (!message.screenshot && message.status) {
setDiagnostic(diagnosticForStatus(message.status));
}
- if (
- message.status === "completed" ||
- message.status === "failed" ||
- message.status === "timeout"
- ) {
+ if (isTerminalStreamStatus(message.status)) {
+ terminalStatusSeenRef.current = true;
socketRef.current?.close();
}
} catch (e) {
@@ -195,16 +219,54 @@ function BrowserSessionStream({
});
socketRef.current.addEventListener("close", (event) => {
- if (!cancelled && !hasFrameRef.current) {
+ if (
+ !cancelled &&
+ !hasFrameRef.current &&
+ !terminalStatusSeenRef.current
+ ) {
setDiagnostic(diagnosticForClose(event));
}
socketRef.current = null;
+
+ const canReconnect =
+ !cancelled &&
+ shouldReconnectStream({
+ closeCode: event.code,
+ closeReason: event.reason,
+ terminalStatusSeen: terminalStatusSeenRef.current,
+ reconnectAttempts: reconnectAttemptsRef.current,
+ });
+
+ if (canReconnect) {
+ reconnectAttemptsRef.current += 1;
+ if (!hasFrameRef.current) {
+ setDiagnostic({
+ ...diagnosticForClose(event),
+ hint: `Reconnecting in ${STREAM_RECONNECT_DELAY_MS / 1000}s (${reconnectAttemptsRef.current}/${STREAM_MAX_RECONNECT_ATTEMPTS}).`,
+ });
+ }
+ clearReconnectTimer();
+ reconnectTimerRef.current = setTimeout(() => {
+ reconnectTimerRef.current = null;
+ void connect();
+ }, STREAM_RECONNECT_DELAY_MS);
+ } else if (
+ !cancelled &&
+ !terminalStatusSeenRef.current &&
+ hasFrameRef.current &&
+ reconnectAttemptsRef.current >= STREAM_MAX_RECONNECT_ATTEMPTS
+ ) {
+ hasFrameRef.current = false;
+ setStreamImgSrc("");
+ setDiagnostic(diagnosticForReconnectExhausted());
+ }
});
}
- run();
+ void connect();
return () => {
cancelled = true;
+ clearReconnectTimer();
if (socketRef.current) {
socketRef.current.close();
socketRef.current = null;
diff --git a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.utils.ts b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.utils.ts
new file mode 100644
index 000000000..78ba6d815
--- /dev/null
+++ b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.utils.ts
@@ -0,0 +1,49 @@
+const TERMINAL_STREAM_STATUSES = new Set([
+ "completed",
+ "failed",
+ "timeout",
+ "not_found",
+]);
+
+const STREAM_RECONNECT_DELAY_MS = 1000;
+const STREAM_MAX_RECONNECT_ATTEMPTS = 20;
+const STREAM_ABNORMAL_CLOSE_CODE = 1006;
+const STREAM_VNC_FALLBACK_CLOSE_CODE = 4001;
+const STREAM_VNC_FALLBACK_CLOSE_REASON = "use-vnc-streaming";
+
+function isTerminalStreamStatus(status: string) {
+ return TERMINAL_STREAM_STATUSES.has(status);
+}
+
+function shouldReconnectStream({
+ closeCode,
+ closeReason,
+ terminalStatusSeen,
+ reconnectAttempts,
+}: {
+ closeCode: number;
+ closeReason: string;
+ terminalStatusSeen: boolean;
+ reconnectAttempts: number;
+}) {
+ if (terminalStatusSeen) {
+ return false;
+ }
+ if (
+ closeCode === STREAM_VNC_FALLBACK_CLOSE_CODE ||
+ closeReason === STREAM_VNC_FALLBACK_CLOSE_REASON
+ ) {
+ return false;
+ }
+ if (closeCode !== STREAM_ABNORMAL_CLOSE_CODE) {
+ return false;
+ }
+ return reconnectAttempts < STREAM_MAX_RECONNECT_ATTEMPTS;
+}
+
+export {
+ STREAM_MAX_RECONNECT_ATTEMPTS,
+ STREAM_RECONNECT_DELAY_MS,
+ isTerminalStreamStatus,
+ shouldReconnectStream,
+};
diff --git a/skyvern/forge/sdk/copilot/agent.py b/skyvern/forge/sdk/copilot/agent.py
index 0b145dfac..e5669816e 100644
--- a/skyvern/forge/sdk/copilot/agent.py
+++ b/skyvern/forge/sdk/copilot/agent.py
@@ -83,6 +83,7 @@ from skyvern.forge.sdk.copilot.request_policy import (
build_request_policy,
redact_raw_secrets_for_prompt,
)
+from skyvern.forge.sdk.copilot.runtime import _browser_context_is_attachable
from skyvern.forge.sdk.copilot.streaming_adapter import (
emit_turn_start,
emit_workflow_draft,
@@ -198,6 +199,21 @@ class CopilotRequestPolicyMissingError(Exception):
"""Raised when the request-policy guardrail fails before producing a policy."""
+def _manager_can_probe_registered_browser_state() -> bool:
+ return app.PERSISTENT_SESSIONS_MANAGER.can_probe_registered_browser_state()
+
+
+async def _registered_browser_state_is_usable(session_id: str, organization_id: str) -> bool:
+ if not _manager_can_probe_registered_browser_state():
+ return False
+
+ state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(
+ session_id=session_id,
+ organization_id=organization_id,
+ )
+ return bool(state and _browser_context_is_attachable(state.browser_context))
+
+
async def _resolve_live_browser_session_id(
chat_request: WorkflowCopilotChatRequest,
organization_id: str,
@@ -230,17 +246,24 @@ async def _resolve_live_browser_session_id(
)
return None
- # Trust the DB row over a CDP probe here — get_browser_state opens a
- # fresh Playwright connection. ensure_browser_session does the
- # attachability probe right before use so stale rows still recover.
persistent = await app.PERSISTENT_SESSIONS_MANAGER.get_session(requested, organization_id)
- if persistent is None or is_final_status(persistent.status) or not persistent.browser_address:
+ has_browser_address = bool(persistent.browser_address) if persistent else False
+ has_registered_browser_state = False
+ if persistent is not None and not is_final_status(persistent.status) and not has_browser_address:
+ has_registered_browser_state = await _registered_browser_state_is_usable(requested, organization_id)
+
+ if (
+ persistent is None
+ or is_final_status(persistent.status)
+ or (not has_browser_address and not has_registered_browser_state)
+ ):
LOG.warning(
"Copilot live browser session is not yet usable; falling back to auto-create",
organization_id=organization_id,
requested_session_id=requested,
status=persistent.status if persistent else None,
- has_browser_address=bool(persistent.browser_address) if persistent else False,
+ has_browser_address=has_browser_address,
+ has_registered_browser_state=has_registered_browser_state,
)
return None
diff --git a/skyvern/forge/sdk/routes/streaming/cdp_input.py b/skyvern/forge/sdk/routes/streaming/cdp_input.py
index 772967d6e..7a685c764 100644
--- a/skyvern/forge/sdk/routes/streaming/cdp_input.py
+++ b/skyvern/forge/sdk/routes/streaming/cdp_input.py
@@ -25,6 +25,7 @@ from skyvern.forge.sdk.routes.streaming.registries import (
from skyvern.forge.sdk.routes.streaming.screencast import wait_for_browser_state
from skyvern.forge.sdk.schemas.persistent_browser_sessions import is_final_status
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus
+from skyvern.webeye.browser_state import BrowserState
LOG = structlog.get_logger()
@@ -37,6 +38,7 @@ _MAX_KEY_LEN = 32
_MAX_CODE_LEN = 32
_MODIFIER_MASK = 0xF
_MAX_VK_CODE = 0xFE
+ACTIVE_PAGE_INPUT_REFRESH_INTERVAL = 0.5
@dataclasses.dataclass
@@ -53,6 +55,63 @@ class CdpInputChannel:
del_cdp_input_channel(self.client_id)
+class ActivePageCdpInputSession:
+ def __init__(
+ self,
+ browser_state: BrowserState,
+ log_id_key: str,
+ log_id_value: str,
+ refresh_interval: float = ACTIVE_PAGE_INPUT_REFRESH_INTERVAL,
+ ) -> None:
+ self.browser_state = browser_state
+ self.log_id_key = log_id_key
+ self.log_id_value = log_id_value
+ self.refresh_interval = refresh_interval
+ self.cdp_session: CDPSession | None = None
+ self.page: object | None = None
+ self.next_refresh_at = 0.0
+ self.page_resolution_failed = False
+
+ async def get_session(self, *, force_refresh: bool = False) -> CDPSession | None:
+ now = time.monotonic()
+ if not force_refresh and now < self.next_refresh_at:
+ return None if self.page_resolution_failed else self.cdp_session
+
+ page = await self.browser_state.get_working_page()
+ if page is None:
+ self.page_resolution_failed = True
+ self.next_refresh_at = now + self.refresh_interval
+ return None
+
+ self.page_resolution_failed = False
+ self.next_refresh_at = now + self.refresh_interval
+ if self.cdp_session is not None and page is self.page:
+ return self.cdp_session
+
+ await self.close()
+ session = await page.context.new_cdp_session(page) # type: ignore[attr-defined]
+ self.cdp_session = session
+ self.page = page
+ LOG.info(
+ "CDP input rebound to active page",
+ **{self.log_id_key: self.log_id_value},
+ url=getattr(page, "url", ""),
+ )
+ return session
+
+ async def close(self) -> None:
+ if self.cdp_session is None:
+ self.page = None
+ return
+ session = self.cdp_session
+ self.cdp_session = None
+ self.page = None
+ try:
+ await session.detach()
+ except Exception:
+ pass
+
+
def _validated_modifiers(msg: dict) -> int:
modifiers = msg.get("modifiers", 0)
if not isinstance(modifiers, int):
@@ -199,11 +258,12 @@ async def _dispatch_event(
async def _run_input_loop(
websocket: WebSocket,
channel: CdpInputChannel,
- cdp_session: CDPSession,
+ input_session: ActivePageCdpInputSession,
log_id_key: str,
log_id_value: str,
) -> None:
dropped_log_count = 0
+ no_active_page_log_count = 0
while True:
try:
raw = await websocket.receive_text()
@@ -238,6 +298,24 @@ async def _run_input_loop(
dropped_log_count += 1
continue
+ try:
+ cdp_session = await input_session.get_session()
+ except Exception:
+ LOG.warning(
+ "CDP input: failed to resolve active page; closing input channel",
+ **{log_id_key: log_id_value},
+ kind=kind,
+ exc_info=True,
+ )
+ await websocket.close(code=4411, reason="active_page_resolution_failed")
+ break
+
+ if cdp_session is None:
+ if no_active_page_log_count < 5:
+ LOG.info("CDP input: no active page; event skipped", **{log_id_key: log_id_value}, kind=kind)
+ no_active_page_log_count += 1
+ continue
+
try:
await _dispatch_event(cdp_session, kind, msg, log_id_key, log_id_value)
except Exception:
@@ -275,6 +353,7 @@ async def cdp_input_stream(
)
cdp_session: CDPSession | None = None
+ input_session: ActivePageCdpInputSession | None = None
try:
deadline = time.monotonic() + 120
while True:
@@ -308,13 +387,18 @@ async def cdp_input_stream(
await websocket.close(code=4410, reason="no_working_page")
return
- cdp_session = await page.context.new_cdp_session(page)
+ input_session = ActivePageCdpInputSession(browser_state, "workflow_run_id", workflow_run_id)
+ cdp_session = await input_session.get_session(force_refresh=True)
+ if cdp_session is None:
+ LOG.warning("CDP input: no working page", workflow_run_id=workflow_run_id)
+ await websocket.close(code=4410, reason="no_working_page")
+ return
stream_ref_inc(workflow_run_id)
LOG.info("CDP input channel ready", workflow_run_id=workflow_run_id, client_id=client_id)
await websocket.send_json({"kind": "ready"})
- await _run_input_loop(websocket, channel, cdp_session, "workflow_run_id", workflow_run_id)
+ await _run_input_loop(websocket, channel, input_session, "workflow_run_id", workflow_run_id)
except ConnectionClosedOK:
LOG.info("CDP input: WS closed cleanly", workflow_run_id=workflow_run_id)
@@ -327,10 +411,8 @@ async def cdp_input_stream(
finally:
if cdp_session is not None:
await stream_ref_dec(workflow_run_id)
- try:
- await cdp_session.detach()
- except Exception:
- pass
+ if input_session is not None:
+ await input_session.close()
await channel.close()
LOG.info("CDP input channel closed", workflow_run_id=workflow_run_id, client_id=client_id)
@@ -358,7 +440,7 @@ async def cdp_input_browser_session_stream(
websocket=websocket,
)
- cdp_session: CDPSession | None = None
+ input_session: ActivePageCdpInputSession | None = None
try:
session = await app.PERSISTENT_SESSIONS_MANAGER.get_session(
session_id=browser_session_id,
@@ -385,12 +467,16 @@ async def cdp_input_browser_session_stream(
await websocket.close(code=4410, reason="no_working_page")
return
- cdp_session = await page.context.new_cdp_session(page)
+ input_session = ActivePageCdpInputSession(browser_state, "browser_session_id", browser_session_id)
+ if await input_session.get_session(force_refresh=True) is None:
+ LOG.warning("CDP input: no working page", browser_session_id=browser_session_id)
+ await websocket.close(code=4410, reason="no_working_page")
+ return
LOG.info("CDP input channel ready", browser_session_id=browser_session_id, client_id=client_id)
await websocket.send_json({"kind": "ready"})
- await _run_input_loop(websocket, channel, cdp_session, "browser_session_id", browser_session_id)
+ await _run_input_loop(websocket, channel, input_session, "browser_session_id", browser_session_id)
except ConnectionClosedOK:
LOG.info("CDP input: WS closed cleanly", browser_session_id=browser_session_id)
@@ -401,10 +487,7 @@ async def cdp_input_browser_session_stream(
except Exception:
LOG.warning("CDP input: unexpected error", browser_session_id=browser_session_id, exc_info=True)
finally:
- if cdp_session is not None:
- try:
- await cdp_session.detach()
- except Exception:
- pass
+ if input_session is not None:
+ await input_session.close()
await channel.close()
LOG.info("CDP input channel closed", browser_session_id=browser_session_id, client_id=client_id)
diff --git a/skyvern/forge/sdk/routes/streaming/screencast.py b/skyvern/forge/sdk/routes/streaming/screencast.py
index b99135b51..9e0fe5dc1 100644
--- a/skyvern/forge/sdk/routes/streaming/screencast.py
+++ b/skyvern/forge/sdk/routes/streaming/screencast.py
@@ -19,6 +19,7 @@ LOG = structlog.get_logger()
DEFAULT_WIDTH = 1280
DEFAULT_HEIGHT = 720
+ACTIVE_PAGE_POLL_INTERVAL = 0.5
async def wait_for_browser_state(
@@ -66,17 +67,27 @@ async def start_screencast_loop(
) -> None:
id_key = f"{entity_type}_id"
cdp_session: CDPSession | None = None
+ attached_page: object | None = None
frame_queue: asyncio.Queue[str] = asyncio.Queue(maxsize=2)
viewport_info: dict[str, int] = {"width": DEFAULT_WIDTH, "height": DEFAULT_HEIGHT}
- async def _ack_frame(session_id: int) -> None:
- if cdp_session is None:
- return
+ async def _ack_frame(session: CDPSession, session_id: int) -> None:
try:
- await cdp_session.send("Page.screencastFrameAck", {"sessionId": session_id})
+ await session.send("Page.screencastFrameAck", {"sessionId": session_id})
except Exception:
pass
+ def _update_viewport_from_page(page: object) -> None:
+ viewport_size = getattr(page, "viewport_size", None)
+ if not isinstance(viewport_size, dict):
+ return
+ width = viewport_size.get("width")
+ height = viewport_size.get("height")
+ if isinstance(width, (int, float)) and width > 0:
+ viewport_info["width"] = int(width)
+ if isinstance(height, (int, float)) and height > 0:
+ viewport_info["height"] = int(height)
+
def _update_viewport_from_metadata(metadata: dict) -> None:
device_width = metadata.get("deviceWidth")
device_height = metadata.get("deviceHeight")
@@ -85,16 +96,9 @@ async def start_screencast_loop(
if isinstance(device_height, (int, float)) and device_height > 0:
viewport_info["height"] = int(device_height)
- async def _on_frame(params: dict) -> None:
- data = params.get("data", "")
- session_id = params.get("sessionId", 0)
- metadata = params.get("metadata", {})
- if metadata:
- _update_viewport_from_metadata(metadata)
- asyncio.create_task(_ack_frame(session_id))
+ def _queue_frame(data: str) -> None:
if not data:
return
- # Drop oldest frame if queue is full to keep latency low
if frame_queue.full():
try:
frame_queue.get_nowait()
@@ -105,6 +109,94 @@ async def start_screencast_loop(
except asyncio.QueueFull:
pass
+ def _drain_frame_queue() -> None:
+ while True:
+ try:
+ frame_queue.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ async def _on_frame(session: CDPSession, params: dict) -> None:
+ if session is not cdp_session:
+ return
+ data = params.get("data", "")
+ session_id = params.get("sessionId", 0)
+ metadata = params.get("metadata", {})
+ if metadata:
+ _update_viewport_from_metadata(metadata)
+ asyncio.create_task(_ack_frame(session, session_id))
+ _queue_frame(data)
+
+ async def _stop_current_screencast() -> None:
+ nonlocal cdp_session, attached_page
+ if cdp_session is None:
+ attached_page = None
+ return
+ session = cdp_session
+ cdp_session = None
+ attached_page = None
+ try:
+ await session.send("Page.stopScreencast", {})
+ except Exception:
+ pass
+ try:
+ await session.detach()
+ except Exception:
+ pass
+
+ async def _prime_current_frame(session: CDPSession, page: object) -> None:
+ try:
+ result = await session.send(
+ "Page.captureScreenshot",
+ {
+ "format": "jpeg",
+ "quality": 60,
+ "captureBeyondViewport": False,
+ },
+ )
+ data = result.get("data", "") if isinstance(result, dict) else ""
+ _update_viewport_from_page(page)
+ _queue_frame(data)
+ except Exception:
+ LOG.debug(
+ "Could not prime CDP screencast frame",
+ entity_id=entity_id,
+ entity_type=entity_type,
+ exc_info=True,
+ )
+
+ async def _attach_to_page(page: object) -> None:
+ nonlocal cdp_session, attached_page
+ if page is attached_page and cdp_session is not None:
+ return
+
+ await _stop_current_screencast()
+ _drain_frame_queue()
+ next_session = await page.context.new_cdp_session(page) # type: ignore[attr-defined]
+ cdp_session = next_session
+ next_session.on("Page.screencastFrame", lambda params: asyncio.create_task(_on_frame(next_session, params)))
+ try:
+ await next_session.send(
+ "Page.startScreencast",
+ {
+ "format": "jpeg",
+ "quality": 60,
+ "maxWidth": DEFAULT_WIDTH,
+ "maxHeight": DEFAULT_HEIGHT,
+ },
+ )
+ except (asyncio.CancelledError, Exception):
+ await _stop_current_screencast()
+ raise
+ attached_page = page
+ await _prime_current_frame(next_session, page)
+ LOG.info(
+ "CDP screencast started",
+ entity_id=entity_id,
+ entity_type=entity_type,
+ url=getattr(page, "url", ""),
+ )
+
async def _frame_forwarding_loop() -> None:
while True:
data = await frame_queue.get()
@@ -144,29 +236,34 @@ async def start_screencast_loop(
exc_info=True,
)
+ async def _active_page_monitor_loop() -> None:
+ while True:
+ await asyncio.sleep(ACTIVE_PAGE_POLL_INTERVAL)
+ try:
+ page = await browser_state.get_working_page()
+ if page is not None and page is not attached_page:
+ await _attach_to_page(page)
+ except Exception:
+ LOG.debug(
+ "Could not refresh CDP screencast active page",
+ entity_id=entity_id,
+ entity_type=entity_type,
+ exc_info=True,
+ )
+
try:
page = await browser_state.get_working_page()
if page is None:
raise RuntimeError("No working page available for screencast")
- cdp_session = await page.context.new_cdp_session(page)
- cdp_session.on("Page.screencastFrame", _on_frame)
- await cdp_session.send(
- "Page.startScreencast",
- {
- "format": "jpeg",
- "quality": 60,
- "maxWidth": DEFAULT_WIDTH,
- "maxHeight": DEFAULT_HEIGHT,
- },
- )
- LOG.info("CDP screencast started", entity_id=entity_id, entity_type=entity_type)
+ await _attach_to_page(page)
forward_task = asyncio.create_task(_frame_forwarding_loop())
poll_task = asyncio.create_task(_completion_polling_loop())
+ page_monitor_task = asyncio.create_task(_active_page_monitor_loop())
done, pending = await asyncio.wait(
- [forward_task, poll_task],
+ [forward_task, poll_task, page_monitor_task],
return_when=asyncio.FIRST_COMPLETED,
)
for task in pending:
@@ -176,10 +273,9 @@ async def start_screencast_loop(
except (asyncio.CancelledError, Exception):
pass
- # Re-raise forwarding errors (e.g. WebSocket disconnect)
for task in done:
exc = task.exception()
- if task is forward_task and exc is not None:
+ if task is not poll_task and exc is not None:
raise exc
except Exception:
@@ -190,13 +286,5 @@ async def start_screencast_loop(
exc_info=True,
)
finally:
- if cdp_session is not None:
- try:
- await cdp_session.send("Page.stopScreencast", {})
- except Exception:
- pass
- try:
- await cdp_session.detach()
- except Exception:
- pass
+ await _stop_current_screencast()
LOG.info("CDP screencast cleaned up", entity_id=entity_id, entity_type=entity_type)
diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.py
index f318d584b..8427741c9 100644
--- a/skyvern/webeye/default_persistent_sessions_manager.py
+++ b/skyvern/webeye/default_persistent_sessions_manager.py
@@ -198,6 +198,9 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
def watch_session_pool(self) -> None:
"""No-op in OSS: browsers run in-process, no external pool to monitor."""
+ def can_probe_registered_browser_state(self) -> bool:
+ return True
+
async def begin_session(
self,
*,
diff --git a/skyvern/webeye/persistent_sessions_manager.py b/skyvern/webeye/persistent_sessions_manager.py
index 05da670bd..cd0b7d4e0 100644
--- a/skyvern/webeye/persistent_sessions_manager.py
+++ b/skyvern/webeye/persistent_sessions_manager.py
@@ -20,6 +20,8 @@ class PersistentSessionsManager(Protocol):
"""Initialize monitoring of the session pool."""
...
+ def can_probe_registered_browser_state(self) -> bool: ...
+
async def begin_session(
self,
*,
diff --git a/tests/unit/test_copilot_live_session_helper.py b/tests/unit/test_copilot_live_session_helper.py
index c8657bfbe..9d417ded9 100644
--- a/tests/unit/test_copilot_live_session_helper.py
+++ b/tests/unit/test_copilot_live_session_helper.py
@@ -98,7 +98,10 @@ async def test_persistent_row_missing_falls_back(monkeypatch: pytest.MonkeyPatch
monkeypatch.setattr(
app,
"PERSISTENT_SESSIONS_MANAGER",
- SimpleNamespace(get_session=AsyncMock(return_value=None)),
+ SimpleNamespace(
+ get_session=AsyncMock(return_value=None),
+ can_probe_registered_browser_state=lambda: False,
+ ),
)
result = await _resolve_live_browser_session_id(
@@ -127,6 +130,7 @@ async def test_status_in_final_state_falls_back(monkeypatch: pytest.MonkeyPatch)
get_session=AsyncMock(
return_value=SimpleNamespace(status="completed", browser_address="wss://example/cdp"),
),
+ can_probe_registered_browser_state=lambda: False,
),
)
@@ -156,6 +160,7 @@ async def test_browser_address_unset_falls_back(monkeypatch: pytest.MonkeyPatch)
get_session=AsyncMock(
return_value=SimpleNamespace(status="running", browser_address=None),
),
+ can_probe_registered_browser_state=lambda: False,
),
)
@@ -167,6 +172,66 @@ async def test_browser_address_unset_falls_back(monkeypatch: pytest.MonkeyPatch)
assert result is None
+async def test_default_manager_registered_browser_state_allows_missing_browser_address(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setattr(
+ app.DATABASE,
+ "debug",
+ SimpleNamespace(
+ get_debug_session_by_browser_session_id=AsyncMock(
+ return_value=SimpleNamespace(workflow_permanent_id="wpid-1"),
+ ),
+ ),
+ )
+ get_browser_state = AsyncMock(return_value=SimpleNamespace(browser_context=_FakeBrowserContext()))
+ manager = SimpleNamespace(
+ get_session=AsyncMock(return_value=SimpleNamespace(status="running", browser_address=None)),
+ get_browser_state=get_browser_state,
+ can_probe_registered_browser_state=lambda: True,
+ )
+ monkeypatch.setattr(app, "PERSISTENT_SESSIONS_MANAGER", manager)
+
+ result = await _resolve_live_browser_session_id(
+ _request(browser_session_id="pbs_booted_local", wpid="wpid-1"),
+ organization_id="org-1",
+ )
+
+ assert result == "pbs_booted_local"
+ get_browser_state.assert_awaited_once_with(session_id="pbs_booted_local", organization_id="org-1")
+
+
+async def test_default_manager_unattachable_registered_browser_state_falls_back(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setattr(
+ app.DATABASE,
+ "debug",
+ SimpleNamespace(
+ get_debug_session_by_browser_session_id=AsyncMock(
+ return_value=SimpleNamespace(workflow_permanent_id="wpid-1"),
+ ),
+ ),
+ )
+ get_browser_state = AsyncMock(return_value=SimpleNamespace(browser_context=None))
+ manager = SimpleNamespace(
+ get_session=AsyncMock(return_value=SimpleNamespace(status="running", browser_address=None)),
+ get_browser_state=get_browser_state,
+ can_probe_registered_browser_state=lambda: True,
+ )
+ monkeypatch.setattr(app, "PERSISTENT_SESSIONS_MANAGER", manager)
+
+ result = await _resolve_live_browser_session_id(
+ _request(browser_session_id="pbs_not_ready", wpid="wpid-1"),
+ organization_id="org-1",
+ )
+
+ assert result is None
+ get_browser_state.assert_awaited_once_with(session_id="pbs_not_ready", organization_id="org-1")
+
+
@pytest.mark.asyncio
async def test_owned_and_running_returns_id(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(
@@ -181,7 +246,10 @@ async def test_owned_and_running_returns_id(monkeypatch: pytest.MonkeyPatch) ->
monkeypatch.setattr(
app,
"PERSISTENT_SESSIONS_MANAGER",
- SimpleNamespace(get_session=AsyncMock(return_value=_running_session())),
+ SimpleNamespace(
+ get_session=AsyncMock(return_value=_running_session()),
+ can_probe_registered_browser_state=lambda: False,
+ ),
)
result = await _resolve_live_browser_session_id(