Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Workstation-persistent extension pairing approval with operator CLI bootstrap (SKY-14820) (#8277)
Suchintan7df3f7718159
diff --git a/skyvern/browser_extension/broker_client.py b/skyvern/browser_extension/broker_client.pyindex 0ec21e64f..8ac19c68f 100644--- a/skyvern/browser_extension/broker_client.py+++ b/skyvern/browser_extension/broker_client.py@@ -226,6 +226,15 @@ class BrokerClient:await self.start()return await self._control_request("pairing.cancel", {}, 5.0)+ async def grant_workstation(self) -> dict[str, Any]:+ await self.start()+ return await self._control_request("workstation.grant", {}, 5.0)++ async def revoke_workstation(self, *, scope: str = "grant") -> dict[str, Any]:+ await self.start()+ args = {} if scope == "grant" else {"scope": scope}+ return await self._control_request("workstation.revoke", args, 5.0)+async def stop_broker(self) -> dict[str, Any]:await self.start()return await self._control_request("broker.stop", {}, 5.0)diff --git a/skyvern/browser_extension/broker_server.py b/skyvern/browser_extension/broker_server.pyindex 4f9997592..ebbef1dec 100644--- a/skyvern/browser_extension/broker_server.py+++ b/skyvern/browser_extension/broker_server.py@@ -73,6 +73,13 @@ from skyvern.browser_extension.errors import ()from skyvern.browser_extension.protocol import ALLOWED_OPS, LEGACY_PROTOCOL_VERSION, PROTOCOL_VERSIONfrom skyvern.browser_extension.relay import ExtensionRelayServer+from skyvern.browser_extension.workstation_grant import (+ WorkstationGrant,+ load_workstation_grant,+ remove_workstation_grant,+ workstation_grant_path,+ write_workstation_grant,+)LOG = structlog.get_logger(__name__)READY_FD_ENV = "SKYVERN_BROWSER_EXTENSION_BROKER_READY_FD"@@ -86,6 +93,9 @@ EXTENSION_RESET_TIMEOUT_SECONDS = 5.0MAX_PENDING_TAB_EVENT_TABS = 64MAX_PENDING_TAB_EVENTS_PER_TAB = 16_LEASED_OPS = frozenset({"debugger.attach", "debugger.send", "debugger.detach", "tabs.activate", "tabs.remove"})+_WORKSTATION_GRANT_OPS = frozenset({"workstation.grant", "workstation.revoke"})+_APPROVAL_SOURCE_INTERACTIVE = "interactive"+_APPROVAL_SOURCE_GRANT = "grant"class Relay(Protocol):@@ -147,6 +157,7 @@ class _Credential:recovery_secret: strconnection_generation: int = 0approved: bool = False+ approval_source: str | None = Noneapproval_event: asyncio.Event = field(default_factory=asyncio.Event)@@ -206,6 +217,8 @@ class BrowserExtensionBrokerServer:self._relay_factory = relay_factoryself._pairing_opener = pairing_openerself._relay: Relay | None = None+ self._broker_auth_token: str | None = None+ self._workstation_grant: WorkstationGrant | None = Noneself._control_server: asyncio.AbstractServer | None = Noneself._daemon_lock: OwnerFileLock | None = Noneself._credentials: dict[str, _Credential] = {}@@ -270,6 +283,8 @@ class BrowserExtensionBrokerServer:self._daemon_lock = daemon_locktry:extension_secret = read_extension_secret(self.paths)+ self._broker_auth_token = extension_secret+ self._workstation_grant = self._load_workstation_grant()stale_leases = reset_lease_journal(self.paths)if stale_leases:LOG.warning(@@ -550,6 +565,32 @@ class BrowserExtensionBrokerServer:raise errorassert credential is not None+ if not operator:+ # Interactive approval is bound to a CONTINUOUSLY CONNECTED agent: it survives+ # overlap socket replacement (same proven client identity, predecessor still live+ # and approved - required for MV3/network reconnects), and dies on true disconnect.+ # It must NEVER be restorable from a stale approval_source after a disconnect cleared it.+ interactive_approval = (+ previous is not None+ and self._clients.get(credential.client_id) is previous+ and not previous.closed+ and not previous.ownership_released+ and credential.approved+ and credential.approval_source == _APPROVAL_SOURCE_INTERACTIVE+ )+ credential.approved = False+ credential.approval_source = None+ credential.approval_event.clear()+ grant = self._load_workstation_grant()+ self._workstation_grant = grant+ if interactive_approval:+ credential.approved = True+ credential.approval_source = _APPROVAL_SOURCE_INTERACTIVE+ credential.approval_event.set()+ elif grant is not None:+ credential.approved = True+ credential.approval_source = _APPROVAL_SOURCE_GRANT+ credential.approval_event.set()credential.connection_generation += 1connection = _ClientConnection(client_id=credential.client_id,@@ -585,23 +626,35 @@ class BrowserExtensionBrokerServer:self._evict_stale_credentials_locked()self._credentials[credential.client_id] = credentialself._clients[credential.client_id] = connection- if previous is not None:- # Publish the successor before fencing the old socket. If the new- # authentication response fails, the old client remains current and- # keeps its leases instead of leaving a closed slot behind.- previous.ownership_released = True- await self._close_connection(previous)+ try:+ if previous is not None:+ # Publish the successor before fencing the old socket. If the new+ # authentication response fails, the old client remains current and+ # keeps its leases instead of leaving a closed slot behind.+ previous.ownership_released = True+ await self._close_connection(previous)+ except BaseException:+ # Ownership transfer failed before the post-handshake cleanup guard.+ self._release_client_locked(connection)+ await self._close_connection(connection)+ raise- relay = self._relay- if (- not connection.operator- and credential.approved- and relay is not None- and relay.connected- and relay.extension_protocol_version == PROTOCOL_VERSION- and not self._extension_reset_quarantined- ):- await self._send_client_snapshot(connection)+ try:+ relay = self._relay+ if (+ not connection.operator+ and credential.approved+ and relay is not None+ and relay.connected+ and relay.extension_protocol_version == PROTOCOL_VERSION+ and not self._extension_reset_quarantined+ ):+ await self._send_client_snapshot(connection)+ except BaseException:+ # If a successor handshake fails after ownership transfer, release the+ # current connection so its credential cannot remain approved-orphaned.+ await self._connection_closed(connection)+ raisereturn connectionasync def _read_requests(self, connection: _ClientConnection) -> None:@@ -772,12 +825,21 @@ class BrowserExtensionBrokerServer:"pairing.begin","pairing.status","pairing.cancel",+ "workstation.grant",+ "workstation.revoke",}:raise BrowserExtensionBrokerError("OP_NOT_ALLOWED", "Operator connection cannot forward extension requests")relay = self._relayif relay is None:raise BrowserExtensionBrokerError("BROKER_STOPPING", "Browser-extension broker is stopping")+ if op in _WORKSTATION_GRANT_OPS and not connection.operator:+ # Same-UID CLI authority is intentional: only the operator may+ # manage the per-user workstation grant envelope.+ raise BrowserExtensionBrokerError(+ "OP_NOT_ALLOWED",+ "Only an operator connection may manage workstation approval",+ )if op == "broker.status":tab_ids = []if not connection.operator and not self._extension_reset_quarantined:@@ -801,6 +863,20 @@ class BrowserExtensionBrokerServer:"tabIds": tab_ids,"quarantines": [],}+ if op == "workstation.grant":+ if args:+ raise BrowserExtensionBrokerError("INVALID_REQUEST", "Workstation grant does not accept arguments")+ return await self._grant_workstation()+ if op == "workstation.revoke":+ if set(args) - {"scope"}:+ raise BrowserExtensionBrokerError("INVALID_REQUEST", "Workstation revoke arguments are invalid")+ scope = args.get("scope", "grant")+ if not isinstance(scope, str) or scope not in {"grant", "all"}:+ raise BrowserExtensionBrokerError(+ "INVALID_REQUEST",+ "Workstation revoke scope must be 'grant' or 'all'",+ )+ return self._revoke_workstation(scope=scope)if op == "extension.wait_connected":timeout = args.get("timeout", 45.0)if isinstance(timeout, bool) or not isinstance(timeout, (int, float)) or not 0 <= timeout <= 45:@@ -953,6 +1029,89 @@ class BrowserExtensionBrokerServer:return {"stopping": True}raise BrowserExtensionBrokerError("OP_NOT_ALLOWED", "Broker operation is not available")+ def _current_auth_token(self) -> str | None:+ return self._broker_auth_token++ def _load_workstation_grant(self) -> WorkstationGrant | None:+ token = self._current_auth_token()+ if token is None:+ return None+ return load_workstation_grant(workstation_grant_path(), token)++ async def _grant_workstation(self) -> dict[str, Any]:+ token = self._current_auth_token()+ if token is None:+ raise BrowserExtensionBrokerError(+ "BROKER_NOT_ENABLED",+ "Browser-extension broker authentication token is unavailable",+ )+ # Local-trust envelope: the broker binds to 127.0.0.1, clients already+ # authenticate with the 0600 local token file, and the pairing click adds+ # HUMAN CONSENT for first use. This grant persists that consent for this OS user.+ grant = write_workstation_grant(workstation_grant_path(), token, source="cli")+ self._workstation_grant = grant+ for client_id in tuple(self._clients):+ await self._approve_client(client_id, source=_APPROVAL_SOURCE_GRANT)+ return {+ "granted": True,+ "source": grant.source,+ "grantedAt": grant.granted_at,+ }++ def _revoke_workstation(self, *, scope: str = "grant") -> dict[str, Any]:+ relay = self._relay+ if relay is not None and self._pairing_owner is not None:+ # Invalidate every pending confirmation before revoking live approvals.+ self._clear_pairing(relay, cancel_nonce=True)+ self._workstation_grant = None+ cleared_grant = 0+ cleared_interactive = 0+ for connection in tuple(self._clients.values()):+ if connection.closed:+ continue+ credential = self._credentials.get(connection.client_id)+ if credential is None:+ continue+ if credential.approval_source == _APPROVAL_SOURCE_GRANT:+ if credential.approved:+ cleared_grant += 1+ elif scope == "all" and credential.approval_source == _APPROVAL_SOURCE_INTERACTIVE:+ if credential.approved:+ cleared_interactive += 1+ else:+ continue+ credential.approved = False+ credential.approval_source = None+ credential.approval_event.clear()++ file_removal_error: str | None = None+ try:+ revoked = remove_workstation_grant(workstation_grant_path())+ except BrowserExtensionBrokerError as exc:+ revoked = False+ file_removal_error = (+ "Workstation grant path failed safety validation"+ if exc.code == "UNSAFE_PATH"+ else "Workstation grant file could not be removed"+ )+ except OSError:+ revoked = False+ file_removal_error = "Workstation grant file could not be removed"++ # workstation.revoke default scope clears grant-source approvals only (existing amended contract).+ # New scope "all" also clears interactive approvals and is the operator's full kill switch.+ result: dict[str, Any] = {+ "revoked": revoked,+ "scope": scope,+ "cleared": {+ "grant": cleared_grant,+ "interactive": cleared_interactive,+ },+ }+ if file_removal_error is not None:+ result["file_removal_error"] = file_removal_error+ return result+async def _pairing_begin(self, connection: _ClientConnection, relay: Relay) -> dict[str, Any]:if relay.connected and relay.extension_protocol_version != PROTOCOL_VERSION:raise BrowserExtensionBrokerError(@@ -1038,12 +1197,19 @@ class BrowserExtensionBrokerServer:credential = self._credentials.get(connection.client_id)return credential is not None and credential.approved- async def _approve_client(self, client_id: str) -> bool:+ async def _approve_client(self, client_id: str, *, source: str = _APPROVAL_SOURCE_INTERACTIVE) -> bool:credential = self._credentials.get(client_id)connection = self._clients.get(client_id)if credential is None or connection is None or connection.closed:return False+ if (+ source == _APPROVAL_SOURCE_GRANT+ and credential.approved+ and credential.approval_source == _APPROVAL_SOURCE_INTERACTIVE+ ):+ return Truecredential.approved = True+ credential.approval_source = sourcecredential.approval_event.set()relay = self._relayif (@@ -1112,10 +1278,31 @@ class BrowserExtensionBrokerServer:approved = approval_nonce in self._approved_pairing_noncesif not approved and secrets.compare_digest(approval_nonce, self._pairing_approval_nonce or ""):owner = self._pairing_owner- approved = owner == "operator" or (owner is not None and await self._approve_client(owner))+ approved = owner == "operator" or (+ owner is not None and await self._approve_client(owner, source=_APPROVAL_SOURCE_INTERACTIVE)+ )if approved and owner is not None:if owner != "operator":self._principal_pairing_begin.pop(owner, None)+ token = self._current_auth_token()+ if token is not None:+ try:+ grant = write_workstation_grant(+ workstation_grant_path(),+ token,+ source="pairing",+ )+ except (BrowserExtensionBrokerError, OSError) as exc:+ LOG.warning(+ "grant not persisted, next client will re-prompt",+ error_type=type(exc).__name__,+ reason=str(exc),+ exc_info=True,+ )+ else:+ self._workstation_grant = grant+ for client_id in tuple(self._clients):+ await self._approve_client(client_id, source=_APPROVAL_SOURCE_GRANT)self._approved_pairing_nonces[approval_nonce] = time.monotonic() + PAIRING_TTL_SECONDSself._clear_pairing(relay, cancel_nonce=False)if approved:@@ -1233,7 +1420,11 @@ class BrowserExtensionBrokerServer:self._release_client_locked(connection)def _release_client_locked(self, connection: _ClientConnection) -> None:- if connection.operator or connection.ownership_released:+ if connection.operator:+ return+ if connection.ownership_released:+ # Overlap replacement transferred ownership to a live successor. A failed+ # successor handshake clears approval in its own connection cleanup.returnif self._clients.get(connection.client_id) is not connection:return@@ -1241,7 +1432,10 @@ class BrowserExtensionBrokerServer:del self._clients[connection.client_id]credential = self._credentials.get(connection.client_id)if credential is not None:+ # Interactive approval is bound to a CONTINUOUSLY CONNECTED agent and+ # dies on true disconnect; clear every approval field before removal.credential.approved = False+ credential.approval_source = Nonecredential.approval_event.clear()if self._pairing_owner == connection.client_id:# An in-flight approval stays alive only while its owner is connected.diff --git a/skyvern/browser_extension/extension/README.md b/skyvern/browser_extension/extension/README.mdindex 15722e414..9a971a3ad 100644--- a/skyvern/browser_extension/extension/README.md+++ b/skyvern/browser_extension/extension/README.md@@ -44,11 +44,14 @@ matching owner-only legacy and broker credentials. `skyvern browser extension-brexplicit idempotent enable/start command, but normal setup does not require it.The broker keeps the extension-facing port reserved after an MCP process exits, and multiple MCP agents share one-daemon concurrently. Each agent receives browser access only after its own **Approve pairing** click. Approval expires-when that agent disconnects. Each approved agent leases its own tabs, popups follow their opener, and user-shared tabs-go to the first agent that claims them. A disconnected extension gets a short reconnect window before session creation-opens the one-click pairing page for you. Use `skyvern browser extension-broker-status` to inspect sanitized state and-`skyvern browser extension-broker-stop` to drain the daemon and release the configured port.+daemon concurrently. A successful pairing creates one persisted workstation approval shared by all MCP agents. Revoke+it with `skyvern browser extension-revoke-workstation`; add `--all` to clear live interactive approvals as the full+kill switch. Interactive approval is bound to a continuously connected agent: it survives overlap socket replacement+(needed for MV3 and network reconnects) but dies on a true disconnect. Each approved agent leases its own tabs, popups+follow their opener, and user-shared tabs go to the first agent that claims them. A disconnected extension gets a+short reconnect window before session creation opens the one-click pairing page for you. Use+`skyvern browser extension-broker-status` to inspect sanitized state and `skyvern browser extension-broker-stop` to+drain the daemon and release the configured port.The extension records broker-created root tabs and popups in Chrome session storage until those tabs close. This letsthe broker close one of its tabs after an external debugger detach removes it from extension scope. The extension stilldiff --git a/skyvern/browser_extension/workstation_grant.py b/skyvern/browser_extension/workstation_grant.pynew file mode 100644index 000000000..4cd4856f4--- /dev/null+++ b/skyvern/browser_extension/workstation_grant.py@@ -0,0 +1,238 @@+from __future__ import annotations++import hashlib+import hmac+import json+import math+import os+import stat+import tempfile+import time+from dataclasses import dataclass+from pathlib import Path+from typing import Any++import structlog++from skyvern.browser_extension.errors import BrowserExtensionBrokerError++GRANT_VERSION = 1+GRANT_FILENAME = "browser_extension_workstation_grant.json"+_GRANT_SOURCES = frozenset({"pairing", "cli"})+_MAX_GRANT_BYTES = 64 * 1024+_MIN_GRANT_EPOCH = 0+_MAX_GRANT_EPOCH = 4_102_444_800 # 2100-01-01 UTC+_TOKEN_BINDING_LENGTH = 64+_TOKEN_BINDING_HEXDIGITS = frozenset("0123456789abcdef")++LOG = structlog.get_logger(__name__)+++@dataclass(frozen=True, slots=True)+class WorkstationGrant:+ version: int+ granted_at: float+ source: str+ token_binding: str++ def to_json(self) -> dict[str, Any]:+ return {+ "version": self.version,+ "granted_at": self.granted_at,+ "source": self.source,+ "token_binding": self.token_binding,+ }+++def workstation_grant_path(settings_dir: Path | None = None) -> Path:+ """Return the owner-only global grant path for this OS user.++ The path is intentionally shared by all broker instances for the user. This+ design assumes one active broker per user.+ """+ directory = Path.home() / ".skyvern" if settings_dir is None else settings_dir+ return directory / GRANT_FILENAME+++def token_binding(token: str) -> str:+ return hashlib.sha256(token.encode("utf-8")).hexdigest()+++def _valid_granted_at(value: object) -> bool:+ if type(value) is int:+ return _MIN_GRANT_EPOCH <= value <= _MAX_GRANT_EPOCH+ if type(value) is float:+ return math.isfinite(value) and _MIN_GRANT_EPOCH <= value <= _MAX_GRANT_EPOCH+ return False+++def _valid_token_binding(value: object) -> bool:+ return (+ isinstance(value, str)+ and len(value) == _TOKEN_BINDING_LENGTH+ and all(character in _TOKEN_BINDING_HEXDIGITS for character in value)+ )+++def validate_workstation_grant(grant: WorkstationGrant, token: str) -> bool:+ if not isinstance(token, str) or not token:+ return False+ return (+ type(grant.version) is int+ and grant.version == GRANT_VERSION+ and isinstance(grant.source, str)+ and grant.source in _GRANT_SOURCES+ and _valid_granted_at(grant.granted_at)+ and _valid_token_binding(grant.token_binding)+ and hmac.compare_digest(grant.token_binding, token_binding(token))+ )+++def load_workstation_grant(path: Path, token: str) -> WorkstationGrant | None:+ """Read and validate a grant, rewriting its mode to 0600 when needed."""+ try:+ payload = _read_json(path)+ if set(payload) != {"version", "granted_at", "source", "token_binding"}:+ return None+ version = payload["version"]+ granted_at = payload["granted_at"]+ source = payload["source"]+ binding = payload["token_binding"]+ if (+ type(version) is not int+ or not _valid_granted_at(granted_at)+ or not isinstance(source, str)+ or not _valid_token_binding(binding)+ ):+ return None+ grant = WorkstationGrant(version, float(granted_at), source, binding)+ return grant if validate_workstation_grant(grant, token) else None+ except FileNotFoundError:+ return None+ except Exception:+ LOG.warning("browser_extension_workstation_grant_invalid", path=str(path), exc_info=True)+ return None+++def write_workstation_grant(+ path: Path,+ token: str,+ *,+ source: str,+ granted_at: float | None = None,+) -> WorkstationGrant:+ if source not in _GRANT_SOURCES:+ raise BrowserExtensionBrokerError("INVALID_REQUEST", "Workstation grant source is invalid")+ if not token:+ raise BrowserExtensionBrokerError("BROKER_NOT_ENABLED", "Broker authentication token is unavailable")+ timestamp = time.time() if granted_at is None else granted_at+ if not _valid_granted_at(timestamp):+ raise BrowserExtensionBrokerError("INVALID_REQUEST", "Workstation grant timestamp is invalid")+ grant = WorkstationGrant(GRANT_VERSION, float(timestamp), source, token_binding(token))+ _atomic_write_json(path, grant.to_json())+ return grant+++def remove_workstation_grant(path: Path) -> bool:+ try:+ file_stat = path.lstat()+ except FileNotFoundError:+ return False+ _validate_file_stat(path, file_stat)+ path.unlink()+ _fsync_directory(path.parent)+ return True+++def _read_json(path: Path) -> dict[str, Any]:+ path_stat = path.lstat()+ _validate_file_stat(path, path_stat)+ flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | os.O_NONBLOCK+ fd = os.open(path, flags)+ try:+ file_stat = os.fstat(fd)+ _validate_file_stat(path, file_stat)+ current_path_stat = path.lstat()+ _validate_file_stat(path, current_path_stat)+ if (file_stat.st_dev, file_stat.st_ino) != (path_stat.st_dev, path_stat.st_ino) or (+ file_stat.st_dev,+ file_stat.st_ino,+ ) != (current_path_stat.st_dev, current_path_stat.st_ino):+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Workstation grant changed during validation")+ if stat.S_IMODE(file_stat.st_mode) != 0o600:+ os.fchmod(fd, 0o600)+ chunks: list[bytes] = []+ total = 0+ while True:+ chunk = os.read(fd, min(65536, _MAX_GRANT_BYTES + 1 - total))+ if not chunk:+ break+ chunks.append(chunk)+ total += len(chunk)+ if total > _MAX_GRANT_BYTES:+ raise BrowserExtensionBrokerError("UNSAFE_STATE", "Workstation grant is too large")+ finally:+ os.close(fd)+ value = json.loads(b"".join(chunks))+ if not isinstance(value, dict):+ raise BrowserExtensionBrokerError("UNSAFE_STATE", "Workstation grant is invalid")+ return value+++def _atomic_write_json(path: Path, value: dict[str, Any]) -> None:+ directory_stat = _validate_directory(path.parent)+ fd, temporary_name = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")+ temporary = Path(temporary_name)+ try:+ os.fchmod(fd, 0o600)+ payload = json.dumps(value, separators=(",", ":"), sort_keys=True, allow_nan=False).encode("utf-8")+ with os.fdopen(fd, "wb") as output:+ fd = -1+ output.write(payload)+ output.flush()+ os.fsync(output.fileno())+ _validate_publication_target(path)+ current_stat = _validate_directory(path.parent)+ if (directory_stat.st_dev, directory_stat.st_ino) != (current_stat.st_dev, current_stat.st_ino):+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Skyvern settings directory changed during publication")+ os.replace(temporary, path)+ _fsync_directory(path.parent)+ finally:+ if fd >= 0:+ os.close(fd)+ temporary.unlink(missing_ok=True)+++def _validate_publication_target(path: Path) -> None:+ try:+ file_stat = path.lstat()+ except FileNotFoundError:+ return+ _validate_file_stat(path, file_stat)+++def _validate_file_stat(path: Path, file_stat: os.stat_result) -> None:+ if not stat.S_ISREG(file_stat.st_mode) or path.is_symlink():+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Workstation grant must be a regular file")+ if hasattr(os, "getuid") and file_stat.st_uid != os.getuid():+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Workstation grant has the wrong owner")+++def _validate_directory(path: Path) -> os.stat_result:+ path.mkdir(mode=0o700, parents=True, exist_ok=True)+ directory_stat = path.lstat()+ if not stat.S_ISDIR(directory_stat.st_mode) or path.is_symlink():+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Skyvern settings directory is unsafe")+ if hasattr(os, "getuid") and directory_stat.st_uid != os.getuid():+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Skyvern settings directory has the wrong owner")+ if stat.S_IMODE(directory_stat.st_mode) & 0o022:+ raise BrowserExtensionBrokerError("UNSAFE_PATH", "Skyvern settings directory is writable by another user")+ return directory_stat+++def _fsync_directory(path: Path) -> None:+ fd = os.open(path, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0) | getattr(os, "O_NOFOLLOW", 0))+ try:+ os.fsync(fd)+ finally:+ os.close(fd)diff --git a/skyvern/cli/commands/browser.py b/skyvern/cli/commands/browser.pyindex 306ec4e3b..8cd26be2b 100644--- a/skyvern/cli/commands/browser.py+++ b/skyvern/cli/commands/browser.py@@ -544,6 +544,73 @@ def extension_broker_stop() -> None:console.print(f"Browser-extension broker stop requested; port {port} will no longer be reserved.")+def extension_approve_workstation() -> None:+ """Persist workstation approval through the authenticated broker control channel."""+ try:+ port = BrowserExtensionRuntime.configured_port()++ async def _run() -> dict[str, Any]:+ client = await _broker_client(port, auto_spawn=False, operator=True)+ try:+ return await client.grant_workstation()+ finally:+ await client.stop()++ result = asyncio.run(_run())+ except (BrowserExtensionError, OSError) as exc:+ console.print(str(exc))+ raise typer.Exit(code=1) from None+ if result.get("granted") is True:+ console.print("Workstation approval: granted.")+ console.print(f"Workstation approval source: {result.get('source', 'cli')}.")+++def extension_revoke_workstation(+ all_scope: bool = typer.Option(False, "--all", help="Also clear live interactive approvals."),+) -> None:+ """Revoke workstation approval through the authenticated broker control channel.++ Interactive approval is bound to a CONTINUOUSLY CONNECTED agent: it survives overlap socket+ replacement (same proven client identity, predecessor still live and approved - required for+ MV3/network reconnects), and dies on true disconnect. It must NEVER be restorable from a stale+ approval_source after a disconnect cleared it.++ workstation.revoke default scope clears grant-source approvals only (existing amended contract).+ New scope "all" also clears interactive approvals and is the operator's full kill switch.+ """+ scope = "all" if all_scope else "grant"+ try:+ port = BrowserExtensionRuntime.configured_port()++ async def _run() -> dict[str, Any]:+ client = await _broker_client(port, auto_spawn=False, operator=True)+ try:+ return await client.revoke_workstation(scope=scope)+ finally:+ await client.stop()++ result = asyncio.run(_run())+ except (BrowserExtensionError, OSError) as exc:+ console.print(str(exc))+ raise typer.Exit(code=1) from None+ if result.get("revoked") is True:+ console.print("Workstation approval: revoked.")+ else:+ console.print("Workstation approval: not present.")+ cleared = result.get("cleared")+ if not isinstance(cleared, dict):+ cleared = {}+ console.print(f"Grant-source approvals cleared: {cleared.get('grant', 0)}.")+ if scope == "all":+ console.print(f"Interactive approvals cleared: {cleared.get('interactive', 0)}.")+ else:+ console.print("Interactive approvals were not cleared; they die on true disconnect.")+ file_removal_error = result.get("file_removal_error")+ if isinstance(file_removal_error, str) and file_removal_error:+ console.print(f"Warning: {file_removal_error}. Inspect the workstation grant file manually before retrying.")+ raise typer.Exit(code=1)++def extension_broker_daemon(port: int = typer.Option(..., "--port", min=1, max=65535),) -> None:@@ -557,6 +624,8 @@ def extension_broker_daemon(browser_app.command("extension-broker-enable")(extension_broker_enable)+browser_app.command("extension-approve-workstation")(extension_approve_workstation)+browser_app.command("extension-revoke-workstation")(extension_revoke_workstation)browser_app.command("extension-broker-pair")(extension_broker_pair)browser_app.command("extension-broker-status")(extension_broker_status)browser_app.command("extension-broker-stop")(extension_broker_stop)diff --git a/tests/smoke_tests/browser_extension/run_extension_smoke.py b/tests/smoke_tests/browser_extension/run_extension_smoke.pyindex bb6696f9d..2eef4b04d 100644--- a/tests/smoke_tests/browser_extension/run_extension_smoke.py+++ b/tests/smoke_tests/browser_extension/run_extension_smoke.py@@ -371,25 +371,12 @@ async def _run_mcp_phase(session_result = await call_tool("skyvern_browser_session_create")else:previous_count = _pairing_url_count(pairing_url_capture)- session_task = asyncio.create_task(call_tool("skyvern_browser_session_create"))- try:- await _approve_next_pairing(context, pairing_url_capture, previous_count)- except BaseException:- if not session_task.done():- session_task.cancel()- try:- incomplete_result = await session_task- except BaseException:- pass- else:- session_created = incomplete_result.get("ok") is True- raise- session_result = await session_task+ session_result = await call_tool("skyvern_browser_session_create")+ if _pairing_url_count(pairing_url_capture) != previous_count:+ raise AssertionError("workstation grant unexpectedly opened a pairing URL")if session_result.get("ok") is not True:raise AssertionError(f"session create failed: {_tool_error(session_result)}")session_created = True- if not legacy_mode:- _assert_one_pairing_url(pairing_url_capture, previous_count)assert pairing_token not in repr(session_result)assert CDP_URL_PATTERN.search(repr(session_result)) is Nonediff --git a/tests/unit/browser_extension/test_broker_server.py b/tests/unit/browser_extension/test_broker_server.pyindex a3130304d..2a30bd9b5 100644--- a/tests/unit/browser_extension/test_broker_server.py+++ b/tests/unit/browser_extension/test_broker_server.py@@ -775,8 +775,10 @@ async def test_pairing_approval_clears_flow_but_preserves_operator_rate_limit()@pytest.mark.asyncio-async def test_each_client_requires_its_own_one_click_approval() -> None:+async def test_pairing_grant_approves_connected_clients(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = "extension-secret"relay = FakeRelay("extension-secret", 19777, server._handle_extension_event, server._handle_disconnect)server._relay = relayfirst = BrokerClient(19777, _ignore_event, auto_spawn=False)@@ -810,13 +812,12 @@ async def test_each_client_requires_its_own_one_click_approval() -> None:)assert (await first.broker_status())["approved"] is True- assert (await second.broker_status())["approved"] is False+ assert await second.wait_connected(1.0) is True+ assert (await second.broker_status())["approved"] is Truefirst_response = await first.request("tabs.create", {"url": "about:blank"})assert first_response["op"] == "tabs.create"- assert first_response["args"] == {"url": "about:blank"}- with pytest.raises(BrowserExtensionBrokerError) as error_info:- await second.request("tabs.create", {"url": "about:blank"})- assert error_info.value.code == "APPROVAL_REQUIRED"+ second_response = await second.request("tabs.create", {"url": "about:blank"})+ assert second_response["op"] == "tabs.create"assert relay.sent_events[-2:] == [("pairing.approved_ack",diff --git a/tests/unit/browser_extension/test_workstation_grant.py b/tests/unit/browser_extension/test_workstation_grant.pynew file mode 100644index 000000000..d9848ec0a--- /dev/null+++ b/tests/unit/browser_extension/test_workstation_grant.py@@ -0,0 +1,651 @@+from __future__ import annotations++import asyncio+import json+import os+from pathlib import Path++import pytest++from skyvern.browser_extension.broker_client import BrokerClient+from skyvern.browser_extension.broker_server import BrowserExtensionBrokerServer+from skyvern.browser_extension.broker_state import ensure_run_directory+from skyvern.browser_extension.errors import BrowserExtensionBrokerError+from skyvern.browser_extension.workstation_grant import (+ load_workstation_grant,+ remove_workstation_grant,+ validate_workstation_grant,+ workstation_grant_path,+ write_workstation_grant,+)++from .test_broker_server import FakeRelay, _connect_over_socketpair, _ignore_event++[email protected]("source", ["pairing", "cli"])+def test_workstation_grant_roundtrip_and_token_binding(tmp_path: Path, source: str) -> None:+ path = workstation_grant_path(tmp_path / ".skyvern")++ grant = write_workstation_grant(path, "token-a", source=source, granted_at=123.5)++ assert load_workstation_grant(path, "token-a") == grant+ assert load_workstation_grant(path, "rotated-token") is None+ path.chmod(0o644)+ assert load_workstation_grant(path, "token-a") == grant+ assert path.stat().st_mode & 0o777 == 0o600+ assert remove_workstation_grant(path) is True+ assert remove_workstation_grant(path) is False+++def test_empty_expected_token_invalidates_workstation_grant(tmp_path: Path) -> None:+ path = workstation_grant_path(tmp_path / ".skyvern")+ grant = write_workstation_grant(path, "token-a", source="cli", granted_at=123.5)++ assert validate_workstation_grant(grant, "") is False+ assert load_workstation_grant(path, "") is None+++async def test_authentication_with_valid_workstation_grant_skips_pairing(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ write_workstation_grant(workstation_grant_path(), token, source="cli")+ server = BrowserExtensionBrokerServer(19777)+ server._broker_auth_token = token+ server._relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ server_task = await _connect_over_socketpair(server, client, auto_approve=False)+ try:+ assert (await client.broker_status())["approved"] is True+ assert server._pairing_owner is None+ finally:+ await client.stop()+ await asyncio.wait_for(server_task, 1.0)+ await server.stop()+++async def test_interactive_pairing_refreshes_workstation_grant_and_approves_peers(+ monkeypatch: pytest.MonkeyPatch,+ tmp_path: Path,+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ server_task = await _connect_over_socketpair(server, client, auto_approve=False)+ peer = BrokerClient(19777, _ignore_event, auto_spawn=False)+ peer_task = await _connect_over_socketpair(server, peer, auto_approve=False)+ try:+ await client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ grant = load_workstation_grant(workstation_grant_path(), token)+ assert grant is not None+ assert grant.source == "pairing"+ assert (await client.broker_status())["approved"] is True+ assert await peer.wait_connected(1.0) is True+ assert (await peer.broker_status())["approved"] is True+ assert server._credentials[peer._client_id].approval_source == "grant"+ finally:+ await peer.stop()+ await asyncio.wait_for(peer_task, 1.0)+ await client.stop()+ await asyncio.wait_for(server_task, 1.0)+ await server.stop()+++async def test_interactive_pairing_ack_survives_grant_persist_failure(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ server_task = await _connect_over_socketpair(server, client, auto_approve=False)++ def fail_write(*_args: object, **_kwargs: object) -> None:+ raise OSError("disk full")++ monkeypatch.setattr("skyvern.browser_extension.broker_server.write_workstation_grant", fail_write)+ try:+ await client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ assert (await client.broker_status())["approved"] is True+ assert server._pairing_owner is None+ assert relay.sent_events[-1] == (+ "pairing.approved_ack",+ {"approvalNonce": offer["approvalNonce"], "approved": True},+ )+ assert not workstation_grant_path().exists()+ finally:+ await client.stop()+ await asyncio.wait_for(server_task, 1.0)+ await server.stop()+++async def test_workstation_control_ops_are_operator_only_and_revoke_future_auth(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ operator = BrokerClient(19777, _ignore_event, auto_spawn=False, operator=True)+ client_task = await _connect_over_socketpair(server, client, auto_approve=False)+ operator_task = await _connect_over_socketpair(server, operator)+ try:+ with pytest.raises(BrowserExtensionBrokerError) as error_info:+ await client.grant_workstation()+ assert error_info.value.code == "OP_NOT_ALLOWED"+ await client.begin_pairing()+ assert server._pairing_owner == client._client_id++ assert (await operator.grant_workstation())["granted"] is True+ assert load_workstation_grant(workstation_grant_path(), token) is not None+ assert (await client.broker_status())["approved"] is True++ assert (await operator.revoke_workstation())["revoked"] is True+ assert server._pairing_owner is None+ assert relay.nonce == "cancelled"+ assert not workstation_grant_path().exists()+ # Grant-approved connections lose approval immediately after revocation.+ assert (await client.broker_status())["approved"] is False++ await client.stop()+ await asyncio.wait_for(client_task, 1.0)+ replacement_task = await _connect_over_socketpair(server, client, auto_approve=False)+ try:+ assert (await client.broker_status())["approved"] is False+ finally:+ await client.stop()+ await asyncio.wait_for(replacement_task, 1.0)+ finally:+ await operator.stop()+ await asyncio.wait_for(operator_task, 1.0)+ await server.stop()+++def _write_malformed_grant(path: Path, kind: str) -> None:+ path.parent.mkdir(mode=0o700)+ if kind == "fifo":+ os.mkfifo(path)+ return+ if kind == "deep_json":+ nested_json = "[" * 3000 + json.dumps("cli") + "]" * 3000+ path.write_text(+ '{"granted_at":123.5,"source":'+ + nested_json+ + ',"token_binding":'+ + json.dumps("0" * 64)+ + ',"version":1}',+ encoding="utf-8",+ )+ else:+ payload: dict[str, object] = {+ "version": 1,+ "granted_at": 123.5,+ "source": "cli",+ "token_binding": "0" * 64,+ }+ if kind == "huge_timestamp":+ payload["granted_at"] = 10**1000+ elif kind == "non_ascii_binding":+ payload["token_binding"] = "é" * 64+ else:+ raise AssertionError(f"unknown malformed grant kind: {kind}")+ path.write_text(json.dumps(payload), encoding="utf-8")+ path.chmod(0o600)+++def _replace_grant_with_unsafe_target(path: Path, kind: str) -> None:+ path.unlink()+ if kind == "fifo":+ os.mkfifo(path)+ elif kind == "symlink":+ path.symlink_to(path.parent / "missing-grant-target")+ else:+ raise AssertionError(f"unknown unsafe grant kind: {kind}")++[email protected]("kind", ["huge_timestamp", "non_ascii_binding", "deep_json", "fifo"])+async def test_malformed_grants_are_no_grant_and_auth_survives(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path, kind: str+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ path = workstation_grant_path()+ _write_malformed_grant(path, kind)+ run_base = tmp_path / "broker-run"+ startup_paths = ensure_run_directory(19777, base_dir=run_base, prepare_control_endpoint=False)+ startup_paths.extension_secret.write_text(token)+ startup_paths.extension_secret.chmod(0o600)++ def relay_factory(secret: str, port: int, on_event, on_disconnect, _on_pairing_complete):+ return FakeRelay(secret, port, on_event, on_disconnect)++ server = BrowserExtensionBrokerServer(19777, base_dir=run_base, relay_factory=relay_factory)+ assert load_workstation_grant(path, token) is None+ await server.start()+ try:+ assert server._workstation_grant is None+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ server_task = await _connect_over_socketpair(server, client, auto_approve=False)+ try:+ assert (await client.broker_status())["approved"] is False+ finally:+ await client.stop()+ await asyncio.wait_for(server_task, 1.0)+ finally:+ await server.stop()+++async def test_revoked_grant_does_not_approve_overlapping_reauthentication(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777)+ server._broker_auth_token = token+ server._relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ operator = BrokerClient(19777, _ignore_event, auto_spawn=False, operator=True)+ client_task = await _connect_over_socketpair(server, client, auto_approve=False)+ operator_task = await _connect_over_socketpair(server, operator)+ replacement: BrokerClient | None = None+ replacement_task: asyncio.Task[None] | None = None+ try:+ await operator.grant_workstation()+ assert (await client.broker_status())["approved"] is True+ await operator.revoke_workstation()+ assert (await client.broker_status())["approved"] is False++ replacement = BrokerClient(19777, _ignore_event, auto_spawn=False)+ replacement._client_id = client._client_id+ replacement._recovery_secret = client._recovery_secret+ replacement_task = await _connect_over_socketpair(server, replacement, auto_approve=False)+ assert (await replacement.broker_status())["approved"] is False+ finally:+ if replacement is not None:+ await replacement.stop()+ if replacement_task is not None:+ await asyncio.wait_for(replacement_task, 1.0)+ await client.stop()+ await asyncio.wait_for(client_task, 1.0)+ await operator.stop()+ await asyncio.wait_for(operator_task, 1.0)+ await server.stop()+++async def test_revoke_preserves_interactive_approval(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ operator = BrokerClient(19777, _ignore_event, auto_spawn=False, operator=True)+ client_task = await _connect_over_socketpair(server, client, auto_approve=False)+ operator_task = await _connect_over_socketpair(server, operator)+ replacement: BrokerClient | None = None+ replacement_task: asyncio.Task[None] | None = None+ try:+ await client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ assert (await client.broker_status())["approved"] is True+ assert server._credentials[client._client_id].approval_source == "interactive"++ result = await operator.revoke_workstation()+ assert result["revoked"] is True+ assert result["scope"] == "grant"+ assert result["cleared"]["interactive"] == 0+ assert (await client.broker_status())["approved"] is True++ replacement = BrokerClient(19777, _ignore_event, auto_spawn=False)+ replacement._client_id = client._client_id+ replacement._recovery_secret = client._recovery_secret+ replacement_task = await _connect_over_socketpair(server, replacement, auto_approve=False)+ assert (await replacement.broker_status())["approved"] is True+ assert server._credentials[client._client_id].approval_source == "interactive"+ finally:+ if replacement is not None:+ await replacement.stop()+ if replacement_task is not None:+ await asyncio.wait_for(replacement_task, 1.0)+ await client.stop()+ await asyncio.wait_for(client_task, 1.0)+ await operator.stop()+ await asyncio.wait_for(operator_task, 1.0)+ await server.stop()+++async def test_interactive_approval_dies_on_true_disconnect(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ client_task = await _connect_over_socketpair(server, client, auto_approve=False)+ replacement: BrokerClient | None = None+ replacement_task: asyncio.Task[None] | None = None+ try:+ await client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ assert (await client.broker_status())["approved"] is True+ assert server._credentials[client._client_id].approval_source == "interactive"++ # Pairing also persists a workstation grant. Remove it to isolate true+ # disconnect semantics from the independent grant-source path.+ assert remove_workstation_grant(workstation_grant_path()) is True+ await client.stop()+ await asyncio.wait_for(client_task, 1.0)++ replacement = BrokerClient(19777, _ignore_event, auto_spawn=False)+ replacement._client_id = client._client_id+ replacement._recovery_secret = client._recovery_secret+ replacement_task = await _connect_over_socketpair(server, replacement, auto_approve=False)+ assert (await replacement.broker_status())["approved"] is False+ credential = server._credentials[client._client_id]+ assert credential.approved is False+ assert credential.approval_source is None+ assert credential.approval_event.is_set() is False+ finally:+ if replacement is not None:+ await replacement.stop()+ if replacement_task is not None:+ await asyncio.wait_for(replacement_task, 1.0)+ await client.stop()+ if not client_task.done():+ await asyncio.wait_for(client_task, 1.0)+ await server.stop()+++async def test_revoke_all_clears_interactive_approval_and_blocks_replacement(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ operator = BrokerClient(19777, _ignore_event, auto_spawn=False, operator=True)+ client_task = await _connect_over_socketpair(server, client, auto_approve=False)+ operator_task = await _connect_over_socketpair(server, operator)+ replacement: BrokerClient | None = None+ replacement_task: asyncio.Task[None] | None = None+ try:+ await client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ assert (await client.broker_status())["approved"] is True++ result = await operator.revoke_workstation(scope="all")+ assert result == {+ "revoked": True,+ "scope": "all",+ "cleared": {"grant": 0, "interactive": 1},+ }+ assert (await client.broker_status())["approved"] is False+ credential = server._credentials[client._client_id]+ assert credential.approved is False+ assert credential.approval_source is None+ assert credential.approval_event.is_set() is False++ replacement = BrokerClient(19777, _ignore_event, auto_spawn=False)+ replacement._client_id = client._client_id+ replacement._recovery_secret = client._recovery_secret+ replacement_task = await _connect_over_socketpair(server, replacement, auto_approve=False)+ assert (await replacement.broker_status())["approved"] is False+ finally:+ if replacement is not None:+ await replacement.stop()+ if replacement_task is not None:+ await asyncio.wait_for(replacement_task, 1.0)+ await client.stop()+ await asyncio.wait_for(client_task, 1.0)+ await operator.stop()+ await asyncio.wait_for(operator_task, 1.0)+ await server.stop()++[email protected]("kind", ["fifo", "symlink"])+async def test_revoke_all_clears_live_approvals_when_grant_path_is_unsafe(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path, kind: str+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ interactive_client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ operator = BrokerClient(19777, _ignore_event, auto_spawn=False, operator=True)+ grant_client: BrokerClient | None = None+ interactive_task = await _connect_over_socketpair(server, interactive_client, auto_approve=False)+ operator_task = await _connect_over_socketpair(server, operator)+ grant_task: asyncio.Task[None] | None = None+ try:+ await interactive_client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ assert server._credentials[interactive_client._client_id].approval_source == "interactive"++ grant_client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ grant_task = await _connect_over_socketpair(server, grant_client, auto_approve=False)+ assert (await grant_client.broker_status())["approved"] is True+ assert server._credentials[grant_client._client_id].approval_source == "grant"++ _replace_grant_with_unsafe_target(workstation_grant_path(), kind)+ result = await operator.revoke_workstation(scope="all")+ assert result == {+ "revoked": False,+ "scope": "all",+ "cleared": {"grant": 1, "interactive": 1},+ "file_removal_error": "Workstation grant path failed safety validation",+ }+ assert (await interactive_client.broker_status())["approved"] is False+ assert (await grant_client.broker_status())["approved"] is False+ finally:+ if grant_client is not None:+ await grant_client.stop()+ if grant_task is not None:+ await asyncio.wait_for(grant_task, 1.0)+ await interactive_client.stop()+ await asyncio.wait_for(interactive_task, 1.0)+ await operator.stop()+ await asyncio.wait_for(operator_task, 1.0)+ await server.stop()+++async def test_revoke_default_clears_live_grant_approval_when_grant_path_is_fifo(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ interactive_client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ operator = BrokerClient(19777, _ignore_event, auto_spawn=False, operator=True)+ grant_client: BrokerClient | None = None+ interactive_task = await _connect_over_socketpair(server, interactive_client, auto_approve=False)+ operator_task = await _connect_over_socketpair(server, operator)+ grant_task: asyncio.Task[None] | None = None+ try:+ await interactive_client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})++ grant_client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ grant_task = await _connect_over_socketpair(server, grant_client, auto_approve=False)+ assert (await grant_client.broker_status())["approved"] is True+ assert server._credentials[grant_client._client_id].approval_source == "grant"++ _replace_grant_with_unsafe_target(workstation_grant_path(), "fifo")+ result = await operator.revoke_workstation()+ assert result == {+ "revoked": False,+ "scope": "grant",+ "cleared": {"grant": 1, "interactive": 0},+ "file_removal_error": "Workstation grant path failed safety validation",+ }+ assert (await grant_client.broker_status())["approved"] is False+ assert (await interactive_client.broker_status())["approved"] is True+ finally:+ if grant_client is not None:+ await grant_client.stop()+ if grant_task is not None:+ await asyncio.wait_for(grant_task, 1.0)+ await interactive_client.stop()+ await asyncio.wait_for(interactive_task, 1.0)+ await operator.stop()+ await asyncio.wait_for(operator_task, 1.0)+ await server.stop()+++async def test_failed_successor_handshake_clears_transferred_approval(+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path+) -> None:+ monkeypatch.setenv("HOME", str(tmp_path))+ token = "broker-token"+ server = BrowserExtensionBrokerServer(19777, pairing_opener=lambda _url: True)+ server._broker_auth_token = token+ relay = FakeRelay(token, 19777, server._handle_extension_event, server._handle_disconnect)+ server._relay = relay+ client = BrokerClient(19777, _ignore_event, auto_spawn=False)+ client_task = await _connect_over_socketpair(server, client, auto_approve=False)+ replacement: BrokerClient | None = None+ replacement_task: asyncio.Task[None] | None = None+ try:+ await client.begin_pairing()+ offer = await server._handle_pairing_complete()+ assert offer is not None+ await relay.emit_event("pairing.approved", {"approvalNonce": offer["approvalNonce"]})+ assert server._credentials[client._client_id].approved is True++ async def fail_snapshot(_connection) -> None:+ raise RuntimeError("successor snapshot failed")++ monkeypatch.setattr(server, "_send_client_snapshot", fail_snapshot)+ replacement = BrokerClient(19777, _ignore_event, auto_spawn=False)+ replacement._client_id = client._client_id+ replacement._recovery_secret = client._recovery_secret+ replacement_task = await _connect_over_socketpair(server, replacement, auto_approve=False)+ await asyncio.wait_for(replacement_task, 1.0)++ credential = server._credentials[client._client_id]+ assert client._client_id not in server._clients+ assert credential.approved is False+ assert credential.approval_source is None+ assert credential.approval_event.is_set() is False+ finally:+ if replacement is not None:+ await replacement.stop()+ if replacement_task is not None and not replacement_task.done():+ await asyncio.wait_for(replacement_task, 1.0)+ await client.stop()+ if not client_task.done():+ await asyncio.wait_for(client_task, 1.0)+ await server.stop()+++def test_workstation_cli_commands_issue_authenticated_control_ops(monkeypatch: pytest.MonkeyPatch) -> None:+ from typer.testing import CliRunner++ from skyvern.cli.commands import browser as browser_commands+ from skyvern.cli.commands.browser import browser_app++ class StubClient:+ def __init__(self) -> None:+ self.grant_calls = 0+ self.revoke_scopes: list[str] = []+ self.stop_calls = 0+ self.fail_revoke = False++ async def grant_workstation(self) -> dict[str, object]:+ self.grant_calls += 1+ return {"granted": True, "source": "cli", "grantedAt": 123.0}++ async def revoke_workstation(self, *, scope: str = "grant") -> dict[str, object]:+ self.revoke_scopes.append(scope)+ result: dict[str, object] = {+ "revoked": True,+ "scope": scope,+ "cleared": {"grant": 1, "interactive": 1 if scope == "all" else 0},+ }+ if self.fail_revoke:+ result["file_removal_error"] = "Workstation grant path failed safety validation"+ return result++ async def stop(self) -> None:+ self.stop_calls += 1++ client = StubClient()+ monkeypatch.setattr(browser_commands, "prepare_cli_runtime", lambda **_kwargs: None)+ monkeypatch.setattr(browser_commands.BrowserExtensionRuntime, "configured_port", lambda: 19777)++ async def fake_broker_client(_port: int, *, auto_spawn: bool, operator: bool) -> StubClient:+ assert auto_spawn is False+ assert operator is True+ return client++ monkeypatch.setattr(browser_commands, "_broker_client", fake_broker_client)+ runner = CliRunner()++ approved = runner.invoke(browser_app, ["extension-approve-workstation"])+ revoked = runner.invoke(browser_app, ["extension-revoke-workstation"])+ revoked_all = runner.invoke(browser_app, ["extension-revoke-workstation", "--all"])+ client.fail_revoke = True+ failed_revoke = runner.invoke(browser_app, ["extension-revoke-workstation"])++ assert approved.exit_code == 0, approved.output+ assert revoked.exit_code == 0, revoked.output+ assert revoked_all.exit_code == 0, revoked_all.output+ assert failed_revoke.exit_code == 1, failed_revoke.output+ assert client.grant_calls == 1+ assert client.revoke_scopes == ["grant", "all", "grant"]+ assert client.stop_calls == 4+ assert "Workstation approval: granted." in approved.output+ assert "Workstation approval source: cli." in approved.output+ assert "Workstation approval: revoked." in revoked.output+ assert "Grant-source approvals cleared: 1." in revoked.output+ assert "Interactive approvals were not cleared; they die on true disconnect." in revoked.output+ assert "Interactive approvals cleared: 1." in revoked_all.output+ assert "Warning: Workstation grant path failed safety validation." in failed_revoke.output