diff --git a/hyperbrowser/__init__.py b/hyperbrowser/__init__.py index f00a570d..5d61788e 100644 --- a/hyperbrowser/__init__.py +++ b/hyperbrowser/__init__.py @@ -2,12 +2,26 @@ from .client.async_client import AsyncHyperbrowser from .config import ClientConfig from .customer_key import CustomerKey, create_customer_key, secret_envelope_digest +from .exceptions import HyperbrowserError +from .image_builds import ( + DockerBuildContextChangedError, + DockerCommandError, + docker_build_context_fingerprint, + docker_image_digest, + image_build_name, +) __all__ = [ "Hyperbrowser", "AsyncHyperbrowser", "ClientConfig", + "HyperbrowserError", "CustomerKey", "create_customer_key", "secret_envelope_digest", + "docker_build_context_fingerprint", + "DockerBuildContextChangedError", + "image_build_name", + "docker_image_digest", + "DockerCommandError", ] diff --git a/hyperbrowser/client/managers/async_manager/sandbox.py b/hyperbrowser/client/managers/async_manager/sandbox.py index d04951ec..c71df5bb 100644 --- a/hyperbrowser/client/managers/async_manager/sandbox.py +++ b/hyperbrowser/client/managers/async_manager/sandbox.py @@ -3,6 +3,7 @@ import time from pathlib import Path from typing import Dict, List, Optional, Union +from urllib.parse import quote from ..._request import coerce_request, dump_request from ....exceptions import HyperbrowserError @@ -375,7 +376,16 @@ async def get_process(self, process_id: str) -> SandboxProcessHandle: return await self.processes.get(process_id) def _hydrate(self, detail: SandboxDetail) -> None: + if ( + detail.startup_secrets is None + and getattr(self, "_detail", None) is not None + and self._detail.startup_secrets is not None + ): + detail = detail.model_copy( + update={"startup_secrets": self._detail.startup_secrets} + ) self._detail = detail + self.startup_secrets = self._detail.startup_secrets self._runtime_session = self._to_runtime_session(detail) async def _resolve_runtime_connection( @@ -396,18 +406,6 @@ async def _resolve_runtime_socket_info(self) -> RuntimeConnection: token=session.token, ) - def _apply_runtime_session(self, session: SandboxRuntimeSession) -> None: - self._runtime_session = _copy_model(session) - self._detail = self._detail.model_copy( - update={ - "status": session.status, - "region": session.region, - "runtime": session.runtime, - "token": session.token, - "token_expires_at": session.token_expires_at, - } - ) - def _clear_runtime_session(self, status: Optional[str] = None) -> None: self._runtime_session = None self._detail = self._detail.model_copy( @@ -492,7 +490,7 @@ async def list( return SandboxListResponse(**payload) async def delete_image(self, image: str) -> SandboxImageDeleteResult: - payload = await self._request("DELETE", f"/images/{image}") + payload = await self._request("DELETE", f"/images/{quote(str(image), safe='')}") return SandboxImageDeleteResult(**payload) async def list_images( @@ -681,15 +679,21 @@ async def list_snapshots( return SandboxSnapshotListResponse(**payload) async def get_snapshot(self, snapshot: str) -> SandboxSnapshotSummary: - payload = await self._request("GET", f"/snapshots/{snapshot}") + payload = await self._request( + "GET", f"/snapshots/{quote(str(snapshot), safe='')}" + ) return SandboxSnapshotSummary(**payload["snapshot"]) async def delete_snapshot(self, snapshot: str) -> SandboxSnapshotDeleteResult: - payload = await self._request("DELETE", f"/snapshots/{snapshot}") + payload = await self._request( + "DELETE", f"/snapshots/{quote(str(snapshot), safe='')}" + ) return SandboxSnapshotDeleteResult(**payload) async def stop(self, sandbox_id: str) -> BasicResponse: - payload = await self._request("PUT", f"/sandbox/{sandbox_id}/stop") + payload = await self._request( + "PUT", f"/sandbox/{quote(str(sandbox_id), safe='')}/stop" + ) return BasicResponse(**payload) async def create_image_build( @@ -707,7 +711,9 @@ async def create_image_build( return SandboxImageBuildCreateResult(**payload) async def get_image_build(self, build_id: str) -> SandboxImageBuild: - payload = await self._request("GET", f"/images/builds/{build_id}") + payload = await self._request( + "GET", f"/images/builds/{quote(str(build_id), safe='')}" + ) return SandboxImageBuild(**payload["build"]) async def reuse_docker_image( @@ -734,13 +740,15 @@ async def complete_image_build( ) -> SandboxImageBuild: payload = await self._request( "POST", - f"/images/builds/{build_id}/complete", + f"/images/builds/{quote(str(build_id), safe='')}/complete", data=dump_request(params, CompleteSandboxImageBuildParams), ) return SandboxImageBuild(**payload["build"]) async def cancel_image_build(self, build_id: str) -> SandboxImageBuild: - payload = await self._request("POST", f"/images/builds/{build_id}/cancel") + payload = await self._request( + "POST", f"/images/builds/{quote(str(build_id), safe='')}/cancel" + ) return SandboxImageBuild(**payload["build"]) async def list_image_builds( @@ -1104,7 +1112,9 @@ async def get_runtime_session(self, sandbox_id: str) -> SandboxRuntimeSession: return session async def get_detail(self, sandbox_id: str) -> SandboxDetail: - payload = await self._request("GET", f"/sandbox/{sandbox_id}") + payload = await self._request( + "GET", f"/sandbox/{quote(str(sandbox_id), safe='')}" + ) return SandboxDetail(**payload) def attach(self, detail: SandboxDetail) -> SandboxHandle: @@ -1119,7 +1129,7 @@ async def create_memory_snapshot( ) -> SandboxMemorySnapshotResult: payload = await self._request( "POST", - f"/sandbox/{sandbox_id}/snapshot", + f"/sandbox/{quote(str(sandbox_id), safe='')}/snapshot", data=dump_request( params if params is not None else {}, SandboxMemorySnapshotParams, @@ -1134,7 +1144,7 @@ async def update_network( ) -> SandboxNetworkUpdateResult: payload = await self._request( "PUT", - f"/sandbox/{sandbox_id}/network", + f"/sandbox/{quote(str(sandbox_id), safe='')}/network", data=dump_request( policy, SandboxNetworkPolicy, @@ -1153,7 +1163,7 @@ async def expose( ) -> SandboxExposeResult: payload = await self._request( "POST", - f"/sandbox/{sandbox_id}/expose", + f"/sandbox/{quote(str(sandbox_id), safe='')}/expose", data=dump_request(params, SandboxExposeParams), ) target_runtime = runtime or (await self.get_detail(sandbox_id)).runtime @@ -1164,7 +1174,7 @@ async def expose( async def unexpose(self, sandbox_id: str, port: int) -> SandboxUnexposeResult: payload = await self._request( "POST", - f"/sandbox/{sandbox_id}/unexpose", + f"/sandbox/{quote(str(sandbox_id), safe='')}/unexpose", data={"port": port}, ) return SandboxUnexposeResult(**payload) @@ -1179,7 +1189,9 @@ async def start_secret_process( """ try: response = await self._request( - "POST", f"/sandbox/{sandbox_id}/processes", data=payload + "POST", + f"/sandbox/{quote(str(sandbox_id), safe='')}/processes", + data=payload, ) except HyperbrowserError as error: raise secret_process_start_error(sandbox_id, error) diff --git a/hyperbrowser/client/managers/async_manager/session.py b/hyperbrowser/client/managers/async_manager/session.py index 3ebc01c5..0a75c06e 100644 --- a/hyperbrowser/client/managers/async_manager/session.py +++ b/hyperbrowser/client/managers/async_manager/session.py @@ -24,6 +24,7 @@ CaptchaEvaluationResponse, CreateSessionParams, CreateSessionSnapshotResponse, + GetActiveSessionsCountResponse, GetSessionDownloadsUrlResponse, GetSessionRecordingUrlResponse, GetSessionVideoRecordingUrlResponse, @@ -139,6 +140,12 @@ async def list( ) return SessionListResponse(**response.data) + async def get_active_sessions_count(self) -> GetActiveSessionsCountResponse: + response = await self._client.transport.get( + self._client._build_url("/sessions/active-count") + ) + return GetActiveSessionsCountResponse(**response.data) + async def get_recording(self, id: str) -> List[SessionRecording]: response = await self._client.transport.get( self._client._build_url(f"/session/{id}/recording"), None, True diff --git a/hyperbrowser/client/managers/async_manager/session_credentials.py b/hyperbrowser/client/managers/async_manager/session_credentials.py index e5e52897..a5826628 100644 --- a/hyperbrowser/client/managers/async_manager/session_credentials.py +++ b/hyperbrowser/client/managers/async_manager/session_credentials.py @@ -5,6 +5,7 @@ CREDENTIAL_FILL_REQUEST_TIMEOUT_SECONDS, fill_credential_payload, ) +from hyperbrowser.exceptions import HyperbrowserError from hyperbrowser.models.credential import CredentialFillResult, FillCredentialParams from hyperbrowser.types.credential import ( FillCredentialParams as FillCredentialParamsDict, @@ -42,10 +43,12 @@ async def fill( ``error.details["details"]["pages"]``; pass one's ``pageId`` as ``page_id``, or a URL prefix as ``page_url``. """ + if not isinstance(session_id, str) or not session_id.strip(): + raise HyperbrowserError("A session ID is required", code="invalid_request") body = fill_credential_payload(params) response = await self._client.transport.post( self._client._build_url( - f"/session/{quote(session_id, safe='')}/credentials/fill" + f"/session/{quote(session_id.strip(), safe='')}/credentials/fill" ), data=body, timeout=max(self._client.timeout, CREDENTIAL_FILL_REQUEST_TIMEOUT_SECONDS), diff --git a/hyperbrowser/client/managers/sandboxes/image_build.py b/hyperbrowser/client/managers/sandboxes/image_build.py index d315c6a1..bb524756 100644 --- a/hyperbrowser/client/managers/sandboxes/image_build.py +++ b/hyperbrowser/client/managers/sandboxes/image_build.py @@ -1224,8 +1224,7 @@ def _follow_context_source_symlinks( ) from exc if not target or "\x00" in target: raise ValueError( - f'build context symlink "{current_relative}" has an ' - "invalid target" + f'build context symlink "{current_relative}" has an invalid target' ) remainder = parts[index + 1 :] @@ -1634,6 +1633,10 @@ def _remove_docker_container(container_id: str) -> None: pass +class DockerCommandError(RuntimeError): + """Raised when a local Docker CLI command fails.""" + + def _run_command(args: Sequence[str]) -> None: _run_command_result(args) @@ -1643,16 +1646,21 @@ def _run_command_output(args: Sequence[str]) -> str: def _run_command_result(args: Sequence[str]) -> subprocess.CompletedProcess: - result = subprocess.run( - list(args), - check=False, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - text=True, - ) + try: + result = subprocess.run( + list(args), + check=False, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + ) + except FileNotFoundError as exc: + raise DockerCommandError( + "docker CLI is required for local Docker image operations" + ) from exc if result.returncode == 0: return result message = result.stderr.strip() if message: - raise RuntimeError(f"{' '.join(args)}: {message}") - raise RuntimeError(f"{' '.join(args)} failed with code {result.returncode}") + raise DockerCommandError(f"{' '.join(args)}: {message}") + raise DockerCommandError(f"{' '.join(args)} failed with code {result.returncode}") diff --git a/hyperbrowser/client/managers/sync_manager/sandbox.py b/hyperbrowser/client/managers/sync_manager/sandbox.py index 5ad0a67e..361614a1 100644 --- a/hyperbrowser/client/managers/sync_manager/sandbox.py +++ b/hyperbrowser/client/managers/sync_manager/sandbox.py @@ -1,6 +1,7 @@ import time from pathlib import Path from typing import Dict, List, Optional, Union +from urllib.parse import quote from ..._request import coerce_request, dump_request from ....exceptions import HyperbrowserError @@ -367,7 +368,16 @@ def get_process(self, process_id: str) -> SandboxProcessHandle: return self.processes.get(process_id) def _hydrate(self, detail: SandboxDetail) -> None: + if ( + detail.startup_secrets is None + and getattr(self, "_detail", None) is not None + and self._detail.startup_secrets is not None + ): + detail = detail.model_copy( + update={"startup_secrets": self._detail.startup_secrets} + ) self._detail = detail + self.startup_secrets = self._detail.startup_secrets self._runtime_session = self._to_runtime_session(detail) def _resolve_runtime_connection( @@ -388,18 +398,6 @@ def _resolve_runtime_socket_info(self) -> RuntimeConnection: token=session.token, ) - def _apply_runtime_session(self, session: SandboxRuntimeSession) -> None: - self._runtime_session = _copy_model(session) - self._detail = self._detail.model_copy( - update={ - "status": session.status, - "region": session.region, - "runtime": session.runtime, - "token": session.token, - "token_expires_at": session.token_expires_at, - } - ) - def _clear_runtime_session(self, status: Optional[str] = None) -> None: self._runtime_session = None self._detail = self._detail.model_copy( @@ -484,7 +482,7 @@ def list( return SandboxListResponse(**payload) def delete_image(self, image: str) -> SandboxImageDeleteResult: - payload = self._request("DELETE", f"/images/{image}") + payload = self._request("DELETE", f"/images/{quote(str(image), safe='')}") return SandboxImageDeleteResult(**payload) def list_images( @@ -670,15 +668,17 @@ def list_snapshots( return SandboxSnapshotListResponse(**payload) def get_snapshot(self, snapshot: str) -> SandboxSnapshotSummary: - payload = self._request("GET", f"/snapshots/{snapshot}") + payload = self._request("GET", f"/snapshots/{quote(str(snapshot), safe='')}") return SandboxSnapshotSummary(**payload["snapshot"]) def delete_snapshot(self, snapshot: str) -> SandboxSnapshotDeleteResult: - payload = self._request("DELETE", f"/snapshots/{snapshot}") + payload = self._request("DELETE", f"/snapshots/{quote(str(snapshot), safe='')}") return SandboxSnapshotDeleteResult(**payload) def stop(self, sandbox_id: str) -> BasicResponse: - payload = self._request("PUT", f"/sandbox/{sandbox_id}/stop") + payload = self._request( + "PUT", f"/sandbox/{quote(str(sandbox_id), safe='')}/stop" + ) return BasicResponse(**payload) def create_image_build( @@ -696,7 +696,9 @@ def create_image_build( return SandboxImageBuildCreateResult(**payload) def get_image_build(self, build_id: str) -> SandboxImageBuild: - payload = self._request("GET", f"/images/builds/{build_id}") + payload = self._request( + "GET", f"/images/builds/{quote(str(build_id), safe='')}" + ) return SandboxImageBuild(**payload["build"]) def reuse_docker_image( @@ -723,13 +725,15 @@ def complete_image_build( ) -> SandboxImageBuild: payload = self._request( "POST", - f"/images/builds/{build_id}/complete", + f"/images/builds/{quote(str(build_id), safe='')}/complete", data=dump_request(params, CompleteSandboxImageBuildParams), ) return SandboxImageBuild(**payload["build"]) def cancel_image_build(self, build_id: str) -> SandboxImageBuild: - payload = self._request("POST", f"/images/builds/{build_id}/cancel") + payload = self._request( + "POST", f"/images/builds/{quote(str(build_id), safe='')}/cancel" + ) return SandboxImageBuild(**payload["build"]) def list_image_builds( @@ -1084,7 +1088,7 @@ def get_runtime_session(self, sandbox_id: str) -> SandboxRuntimeSession: return session def get_detail(self, sandbox_id: str) -> SandboxDetail: - payload = self._request("GET", f"/sandbox/{sandbox_id}") + payload = self._request("GET", f"/sandbox/{quote(str(sandbox_id), safe='')}") return SandboxDetail(**payload) def attach(self, detail: SandboxDetail) -> SandboxHandle: @@ -1099,7 +1103,7 @@ def create_memory_snapshot( ) -> SandboxMemorySnapshotResult: payload = self._request( "POST", - f"/sandbox/{sandbox_id}/snapshot", + f"/sandbox/{quote(str(sandbox_id), safe='')}/snapshot", data=dump_request( params if params is not None else {}, SandboxMemorySnapshotParams, @@ -1114,7 +1118,7 @@ def update_network( ) -> SandboxNetworkUpdateResult: payload = self._request( "PUT", - f"/sandbox/{sandbox_id}/network", + f"/sandbox/{quote(str(sandbox_id), safe='')}/network", data=dump_request( policy, SandboxNetworkPolicy, @@ -1133,7 +1137,7 @@ def expose( ) -> SandboxExposeResult: payload = self._request( "POST", - f"/sandbox/{sandbox_id}/expose", + f"/sandbox/{quote(str(sandbox_id), safe='')}/expose", data=dump_request(params, SandboxExposeParams), ) target_runtime = runtime or self.get_detail(sandbox_id).runtime @@ -1144,7 +1148,7 @@ def expose( def unexpose(self, sandbox_id: str, port: int) -> SandboxUnexposeResult: payload = self._request( "POST", - f"/sandbox/{sandbox_id}/unexpose", + f"/sandbox/{quote(str(sandbox_id), safe='')}/unexpose", data={"port": port}, ) return SandboxUnexposeResult(**payload) @@ -1157,7 +1161,9 @@ def start_secret_process(self, sandbox_id: str, payload: Dict[str, object]) -> d """ try: response = self._request( - "POST", f"/sandbox/{sandbox_id}/processes", data=payload + "POST", + f"/sandbox/{quote(str(sandbox_id), safe='')}/processes", + data=payload, ) except HyperbrowserError as error: raise secret_process_start_error(sandbox_id, error) diff --git a/hyperbrowser/client/managers/sync_manager/session.py b/hyperbrowser/client/managers/sync_manager/session.py index adcf782b..30ed2f06 100644 --- a/hyperbrowser/client/managers/sync_manager/session.py +++ b/hyperbrowser/client/managers/sync_manager/session.py @@ -24,6 +24,7 @@ CaptchaEvaluationResponse, CreateSessionParams, CreateSessionSnapshotResponse, + GetActiveSessionsCountResponse, GetSessionDownloadsUrlResponse, GetSessionRecordingUrlResponse, GetSessionVideoRecordingUrlResponse, @@ -139,6 +140,12 @@ def list( ) return SessionListResponse(**response.data) + def get_active_sessions_count(self) -> GetActiveSessionsCountResponse: + response = self._client.transport.get( + self._client._build_url("/sessions/active-count") + ) + return GetActiveSessionsCountResponse(**response.data) + def get_recording(self, id: str) -> List[SessionRecording]: response = self._client.transport.get( self._client._build_url(f"/session/{id}/recording"), None, True diff --git a/hyperbrowser/client/managers/sync_manager/session_credentials.py b/hyperbrowser/client/managers/sync_manager/session_credentials.py index e86d3af4..49d12e6c 100644 --- a/hyperbrowser/client/managers/sync_manager/session_credentials.py +++ b/hyperbrowser/client/managers/sync_manager/session_credentials.py @@ -5,6 +5,7 @@ CREDENTIAL_FILL_REQUEST_TIMEOUT_SECONDS, fill_credential_payload, ) +from hyperbrowser.exceptions import HyperbrowserError from hyperbrowser.models.credential import CredentialFillResult, FillCredentialParams from hyperbrowser.types.credential import ( FillCredentialParams as FillCredentialParamsDict, @@ -42,10 +43,12 @@ def fill( ``error.details["details"]["pages"]``; pass one's ``pageId`` as ``page_id``, or a URL prefix as ``page_url``. """ + if not isinstance(session_id, str) or not session_id.strip(): + raise HyperbrowserError("A session ID is required", code="invalid_request") body = fill_credential_payload(params) response = self._client.transport.post( self._client._build_url( - f"/session/{quote(session_id, safe='')}/credentials/fill" + f"/session/{quote(session_id.strip(), safe='')}/credentials/fill" ), data=body, timeout=max(self._client.timeout, CREDENTIAL_FILL_REQUEST_TIMEOUT_SECONDS), diff --git a/hyperbrowser/image_builds.py b/hyperbrowser/image_builds.py index d8c81312..71ba448a 100644 --- a/hyperbrowser/image_builds.py +++ b/hyperbrowser/image_builds.py @@ -1,5 +1,17 @@ """Content-derived image names for build-or-wait workflows.""" +from .client.managers.sandboxes.image_build import ( + DockerBuildContextChangedError, + DockerCommandError, + docker_build_context_fingerprint, + docker_image_digest, +) from .client.managers.sandboxes.image_resolution import image_build_name -__all__ = ["image_build_name"] +__all__ = [ + "docker_build_context_fingerprint", + "DockerBuildContextChangedError", + "image_build_name", + "docker_image_digest", + "DockerCommandError", +] diff --git a/hyperbrowser/models/__init__.py b/hyperbrowser/models/__init__.py index 9e9e6ffd..0c239377 100644 --- a/hyperbrowser/models/__init__.py +++ b/hyperbrowser/models/__init__.py @@ -345,6 +345,7 @@ CreateSessionParams, CreateSessionProfile, CreateSessionSnapshotResponse, + GetActiveSessionsCountResponse, GetSessionDownloadsUrlResponse, GetSessionRecordingUrlResponse, GetSessionVideoRecordingUrlResponse, @@ -760,6 +761,7 @@ "CreateSessionParams", "CreateSessionProfile", "CreateSessionSnapshotResponse", + "GetActiveSessionsCountResponse", "GetSessionDownloadsUrlResponse", "GetSessionRecordingUrlResponse", "GetSessionVideoRecordingUrlResponse", diff --git a/hyperbrowser/models/session.py b/hyperbrowser/models/session.py index 4866d533..9998ef21 100644 --- a/hyperbrowser/models/session.py +++ b/hyperbrowser/models/session.py @@ -17,7 +17,7 @@ SessionStatus = Literal["active", "closed", "error", "close-error"] BrowserMemorySize = Literal["small", "medium", "large"] -CaptchaSolverType = Literal["visual"] +CaptchaSolverType = Union[Literal["visual"], str] CaptchaEvaluationType = Literal[ "turnstile", "cloudflare-challenge", @@ -195,6 +195,12 @@ class SessionLaunchState(BaseModel): disable_post_quantum_key_agreement: Optional[bool] = Field( default=None, alias="disablePostQuantumKeyAgreement" ) + enable_webgl_fingerprinting: Optional[bool] = Field( + default=None, alias="enableWebglFingerprinting" + ) + """Deprecated and discontinued: WebGL fingerprinting was removed from the + browser and the server ignores this option. Kept so existing code that + sets or reads it keeps working.""" class SessionCreditBreakdown(BaseModel): @@ -658,6 +664,12 @@ class CreateSessionParams(BaseModel): disable_post_quantum_key_agreement: Optional[bool] = Field( default=None, serialization_alias="disablePostQuantumKeyAgreement" ) + enable_webgl_fingerprinting: Optional[bool] = Field( + default=None, serialization_alias="enableWebglFingerprinting" + ) + """Deprecated and discontinued: WebGL fingerprinting was removed from the + browser and the server ignores this option. Kept so existing code that + sets or reads it keeps working.""" browser_memory_size: Optional[BrowserMemorySize] = Field( default=None, serialization_alias="browserMemorySize" ) @@ -676,6 +688,18 @@ class CreateSessionParams(BaseModel): filled, and can only be attached when the session is created.""" +class GetActiveSessionsCountResponse(BaseModel): + """ + Response containing the active sessions count. + """ + + model_config = ConfigDict( + populate_by_alias=True, + ) + + active_sessions_count: int = Field(alias="activeSessionsCount") + + class CreateSessionSnapshotResponse(BaseModel): """ Response from creating a restorable snapshot of a browser session. diff --git a/hyperbrowser/sandbox_common.py b/hyperbrowser/sandbox_common.py index 75217ef6..ece969a8 100644 --- a/hyperbrowser/sandbox_common.py +++ b/hyperbrowser/sandbox_common.py @@ -1,3 +1,4 @@ +import asyncio import json import random import re @@ -154,8 +155,11 @@ def _parse_error_payload( raw_text: str, fallback_message: str ) -> Tuple[str, Optional[str], Any, Optional[json.JSONDecodeError]]: if not raw_text: - return fallback_message, None, None, json.JSONDecodeError( - "Empty response body", raw_text, 0 + return ( + fallback_message, + None, + None, + json.JSONDecodeError("Empty response body", raw_text, 0), ) try: @@ -260,7 +264,7 @@ def normalize_runtime_api_path(pathname: str, prepend_sandbox: bool) -> str: if absolute == "/sandbox": return "/" if absolute.startswith("/sandbox/"): - return f"/{absolute[len('/sandbox/'):]}" + return f"/{absolute[len('/sandbox/') :]}" return absolute @@ -386,7 +390,7 @@ def normalize_network_error( ) -> HyperbrowserError: if isinstance(error, HyperbrowserError): return error - if not isinstance(error, Exception): + if not isinstance(error, Exception) or isinstance(error, asyncio.CancelledError): # CancelledError, KeyboardInterrupt and SystemExit are control flow, not # transport failures. Callers catch BaseException around their requests, # so wrapping these would strand the cancellation and report a request diff --git a/hyperbrowser/tools/__init__.py b/hyperbrowser/tools/__init__.py index a8ae3080..644f914b 100644 --- a/hyperbrowser/tools/__init__.py +++ b/hyperbrowser/tools/__init__.py @@ -29,6 +29,7 @@ CRAWL_TOOL_ANTHROPIC, ) from .gemini import FILL_CREDENTIAL_TOOL_GEMINI +from .schema import FILL_CREDENTIAL_DESCRIPTION, FILL_CREDENTIAL_SCHEMA class WebsiteScrapeTool: @@ -130,14 +131,22 @@ class BrowserUseTool: @staticmethod def runnable(hb: Hyperbrowser, params: StartBrowserUseTaskParams) -> str: resp = hb.agents.browser_use.start_and_wait(params=params) - return resp.data.final_result if resp.data and resp.data.final_result else "" + return ( + resp.data.final_result + if resp.data and resp.data.final_result + else resp.error or "" + ) @staticmethod async def async_runnable( hb: AsyncHyperbrowser, params: StartBrowserUseTaskParams ) -> str: resp = await hb.agents.browser_use.start_and_wait(params=params) - return resp.data.final_result if resp.data and resp.data.final_result else "" + return ( + resp.data.final_result + if resp.data and resp.data.final_result + else resp.error or "" + ) def _present(value: Any) -> bool: @@ -250,6 +259,11 @@ async def async_runnable( __all__ = [ "CredentialFillTool", + "FILL_CREDENTIAL_DESCRIPTION", + "FILL_CREDENTIAL_SCHEMA", + "FILL_CREDENTIAL_TOOL_ANTHROPIC", + "FILL_CREDENTIAL_TOOL_GEMINI", + "FILL_CREDENTIAL_TOOL_OPENAI", "WebsiteScrapeTool", "WebsiteScreenshotTool", "WebsiteCrawlTool", diff --git a/hyperbrowser/transport/async_transport.py b/hyperbrowser/transport/async_transport.py index 7b10a2ce..a01e9d7a 100644 --- a/hyperbrowser/transport/async_transport.py +++ b/hyperbrowser/transport/async_transport.py @@ -10,7 +10,6 @@ error_payload_retryable, get_request_id, get_retry_delay_seconds, - is_retryable_network_error, normalize_network_error, request_context, should_retry_get, @@ -22,8 +21,8 @@ class AsyncTransport(TransportStrategy): """Asynchronous transport implementation using httpx""" def __init__(self, api_key: str): - self.client = httpx.AsyncClient(headers={"x-api-key": api_key}) self._closed = False + self.client = httpx.AsyncClient(headers={"x-api-key": api_key}) async def close(self) -> None: if not self._closed: @@ -86,11 +85,15 @@ async def _handle_response(self, response: httpx.Response) -> APIResponse: service="control", ) except httpx.RequestError as e: - raise HyperbrowserError( + req = getattr(response, "_request", None) or getattr(e, "_request", None) + raise normalize_network_error( + e, + "control", "Request failed", - original_error=e, - retryable=is_retryable_network_error(e), - service="control", + request_context( + req.method if req is not None else None, + str(req.url) if req is not None else None, + ), ) async def post( @@ -146,20 +149,35 @@ async def get( await asyncio.sleep(get_retry_delay_seconds(failed_attempt)) failed_attempt += 1 - async def put(self, url: str, data: Optional[dict] = None) -> APIResponse: + async def put( + self, + url: str, + data: Optional[dict] = None, + timeout: Optional[float] = None, + ) -> APIResponse: try: - response = await self.client.put(url, json=data) + kwargs = {} + if timeout is not None: + kwargs["timeout"] = timeout + response = await self.client.put(url, json=data, **kwargs) return await self._handle_response(response) - except HyperbrowserError: - raise - except Exception as e: - raise HyperbrowserError("Put request failed", original_error=e) + except BaseException as e: + raise normalize_network_error( + e, "control", "Request failed", request_context("PUT", url) + ) - async def delete(self, url: str) -> APIResponse: + async def delete( + self, + url: str, + timeout: Optional[float] = None, + ) -> APIResponse: try: - response = await self.client.delete(url) + kwargs = {} + if timeout is not None: + kwargs["timeout"] = timeout + response = await self.client.delete(url, **kwargs) return await self._handle_response(response) - except HyperbrowserError: - raise - except Exception as e: - raise HyperbrowserError("Delete request failed", original_error=e) + except BaseException as e: + raise normalize_network_error( + e, "control", "Request failed", request_context("DELETE", url) + ) diff --git a/hyperbrowser/transport/base.py b/hyperbrowser/transport/base.py index d25ad655..fad557f6 100644 --- a/hyperbrowser/transport/base.py +++ b/hyperbrowser/transport/base.py @@ -66,9 +66,18 @@ def get( pass @abstractmethod - def put(self, url: str) -> APIResponse: + def put( + self, + url: str, + data: Optional[dict] = None, + timeout: Optional[float] = None, + ) -> APIResponse: pass @abstractmethod - def delete(self, url: str) -> APIResponse: + def delete( + self, + url: str, + timeout: Optional[float] = None, + ) -> APIResponse: pass diff --git a/hyperbrowser/transport/sync.py b/hyperbrowser/transport/sync.py index 5b921267..fc32ae04 100644 --- a/hyperbrowser/transport/sync.py +++ b/hyperbrowser/transport/sync.py @@ -11,7 +11,6 @@ error_payload_retryable, get_request_id, get_retry_delay_seconds, - is_retryable_network_error, normalize_network_error, request_context, should_retry_get, @@ -64,11 +63,15 @@ def _handle_response(self, response: httpx.Response) -> APIResponse: service="control", ) except httpx.RequestError as e: - raise HyperbrowserError( + req = getattr(response, "_request", None) or getattr(e, "_request", None) + raise normalize_network_error( + e, + "control", "Request failed", - original_error=e, - retryable=is_retryable_network_error(e), - service="control", + request_context( + req.method if req is not None else None, + str(req.url) if req is not None else None, + ), ) def close(self) -> None: @@ -127,20 +130,35 @@ def get( time.sleep(get_retry_delay_seconds(failed_attempt)) failed_attempt += 1 - def put(self, url: str, data: Optional[dict] = None) -> APIResponse: + def put( + self, + url: str, + data: Optional[dict] = None, + timeout: Optional[float] = None, + ) -> APIResponse: try: - response = self.client.put(url, json=data) + kwargs = {} + if timeout is not None: + kwargs["timeout"] = timeout + response = self.client.put(url, json=data, **kwargs) return self._handle_response(response) - except HyperbrowserError: - raise - except Exception as e: - raise HyperbrowserError("Put request failed", original_error=e) + except BaseException as e: + raise normalize_network_error( + e, "control", "Request failed", request_context("PUT", url) + ) - def delete(self, url: str) -> APIResponse: + def delete( + self, + url: str, + timeout: Optional[float] = None, + ) -> APIResponse: try: - response = self.client.delete(url) + kwargs = {} + if timeout is not None: + kwargs["timeout"] = timeout + response = self.client.delete(url, **kwargs) return self._handle_response(response) - except HyperbrowserError: - raise - except Exception as e: - raise HyperbrowserError("Delete request failed", original_error=e) + except BaseException as e: + raise normalize_network_error( + e, "control", "Request failed", request_context("DELETE", url) + ) diff --git a/hyperbrowser/types/session.py b/hyperbrowser/types/session.py index 72430bec..e72396b1 100644 --- a/hyperbrowser/types/session.py +++ b/hyperbrowser/types/session.py @@ -15,7 +15,7 @@ SessionStatus = Literal["active", "closed", "error", "close-error"] BrowserMemorySize = Literal["small", "medium", "large"] -CaptchaSolverType = Literal["visual"] +CaptchaSolverType = Union[Literal["visual"], str] CaptchaEvaluationType = Literal[ "turnstile", "cloudflare-challenge", @@ -210,6 +210,7 @@ class CreateSessionParams(TypedDict, total=False): live_view_ttl_seconds: Optional[int] replace_native_elements: Optional[bool] disable_post_quantum_key_agreement: Optional[bool] + enable_webgl_fingerprinting: Optional[bool] # Deprecated: ignored by the server browser_memory_size: Optional[BrowserMemorySize] start_from_snapshot: Optional[StartSessionFromSnapshotParams] credentials: Optional[List[SessionCredentialInput]] @@ -246,6 +247,7 @@ class SessionEventLogListParams(TypedDict, total=False): "CreateSessionParams", "CreateSessionProfile", "ImageCaptchaParam", + "ProxyRoute", "ScreenConfig", "SessionEventLogListParams", "SessionGetParams", @@ -257,4 +259,5 @@ class SessionEventLogListParams(TypedDict, total=False): "UpdateSessionProxyParams", "UpdateSessionScreenParams", "UpdateSessionSolveCaptchasParams", + "WebBotAuthParams", ] diff --git a/pyproject.toml b/pyproject.toml index 37ca417d..68d23222 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "hyperbrowser" -version = "1.15.0" +version = "1.15.1" description = "Python SDK for hyperbrowser" authors = ["Nikhil Shahi "] license = "MIT" diff --git a/tests/test_sdk_audit_fixes.py b/tests/test_sdk_audit_fixes.py new file mode 100644 index 00000000..b0c5f3b1 --- /dev/null +++ b/tests/test_sdk_audit_fixes.py @@ -0,0 +1,532 @@ +import inspect +from types import SimpleNamespace + +import httpx +import pytest + +import hyperbrowser +import hyperbrowser.image_builds as image_builds +import hyperbrowser.models as models +import hyperbrowser.tools as tools +import hyperbrowser.types.session as session_types +from hyperbrowser import AsyncHyperbrowser, Hyperbrowser, HyperbrowserError +from hyperbrowser.client.managers.async_manager.sandbox import ( + SandboxHandle as AsyncSandboxHandle, +) +from hyperbrowser.client.managers.sandboxes.image_build import ( + DockerCommandError, + _run_command_result, +) +from hyperbrowser.client.managers.sync_manager.sandbox import SandboxHandle +from hyperbrowser.models.agents.browser_use import ( + BrowserUseTaskData, + BrowserUseTaskResponse, +) +from hyperbrowser.models.sandbox import SandboxDetail +from hyperbrowser.models.session import ( + CreateSessionParams, + GetActiveSessionsCountResponse, + SessionLaunchState, +) +from hyperbrowser.transport.async_transport import AsyncTransport +from hyperbrowser.transport.base import TransportStrategy +from hyperbrowser.transport.sync import SyncTransport +from tests.test_sandbox_wire_contract import ( + SANDBOX_DETAIL_PAYLOAD, + SNAPSHOT_LIST_PAYLOAD, + SNAPSHOT_RESULT_PAYLOAD, +) + + +def test_top_level_and_submodule_exports(): + assert hyperbrowser.HyperbrowserError is HyperbrowserError + for symbol in ( + "docker_build_context_fingerprint", + "DockerBuildContextChangedError", + "image_build_name", + "docker_image_digest", + "DockerCommandError", + ): + assert hasattr(hyperbrowser, symbol), symbol + assert symbol in hyperbrowser.__all__, symbol + assert hasattr(image_builds, symbol), symbol + assert symbol in image_builds.__all__, symbol + assert getattr(hyperbrowser, symbol) is getattr(image_builds, symbol) + + assert issubclass(DockerCommandError, RuntimeError) + + assert "WebBotAuthParams" in session_types.__all__ + assert "ProxyRoute" in session_types.__all__ + + for tool_symbol in ( + "FILL_CREDENTIAL_TOOL_OPENAI", + "FILL_CREDENTIAL_TOOL_ANTHROPIC", + "FILL_CREDENTIAL_TOOL_GEMINI", + "FILL_CREDENTIAL_DESCRIPTION", + "FILL_CREDENTIAL_SCHEMA", + ): + assert hasattr(tools, tool_symbol), tool_symbol + assert tool_symbol in tools.__all__, tool_symbol + + assert models.GetActiveSessionsCountResponse is GetActiveSessionsCountResponse + assert "GetActiveSessionsCountResponse" in models.__all__ + + +def test_docker_command_error_raised_on_missing_or_failing_command(monkeypatch): + def raise_missing(*args, **kwargs): + raise FileNotFoundError("No such file or directory: 'docker'") + + monkeypatch.setattr("subprocess.run", raise_missing) + with pytest.raises(DockerCommandError, match="docker CLI is required"): + _run_command_result(["docker", "info"]) + + +def test_transport_put_and_delete_accept_timeout_and_normalize_errors(): + for method_name in ("put", "delete"): + sig = inspect.signature(getattr(TransportStrategy, method_name)) + assert "timeout" in sig.parameters + assert sig.parameters["timeout"].default is None + + recorded_Timeouts = [] + + class DummySyncClient: + def put(self, url, json=None, timeout=None): + recorded_Timeouts.append(("PUT", url, timeout)) + raise httpx.ReadTimeout("", request=httpx.Request("PUT", url)) + + def delete(self, url, timeout=None): + recorded_Timeouts.append(("DELETE", url, timeout)) + raise httpx.ConnectError( + "connection reset", request=httpx.Request("DELETE", url) + ) + + sync_transport = SyncTransport.__new__(SyncTransport) + sync_transport.client = DummySyncClient() + + with pytest.raises(HyperbrowserError) as put_exc: + sync_transport.put( + "https://api.hyperbrowser.ai/api/session/s1/stop", timeout=12.5 + ) + assert put_exc.value.retryable is True + assert put_exc.value.service == "control" + assert "[PUT /api/session/s1/stop]" in str(put_exc.value) + + with pytest.raises(HyperbrowserError) as del_exc: + sync_transport.delete("https://api.hyperbrowser.ai/api/volume/v1", timeout=7.0) + assert del_exc.value.retryable is True + assert del_exc.value.service == "control" + assert "[DELETE /api/volume/v1]" in str(del_exc.value) + assert recorded_Timeouts == [ + ("PUT", "https://api.hyperbrowser.ai/api/session/s1/stop", 12.5), + ("DELETE", "https://api.hyperbrowser.ai/api/volume/v1", 7.0), + ] + + +@pytest.mark.anyio +async def test_async_transport_put_and_delete_accept_timeout_and_normalize_errors(): + recorded_timeouts = [] + + class DummyAsyncClient: + async def put(self, url, json=None, timeout=None): + recorded_timeouts.append(("PUT", url, timeout)) + raise httpx.ReadTimeout("", request=httpx.Request("PUT", url)) + + async def delete(self, url, timeout=None): + recorded_timeouts.append(("DELETE", url, timeout)) + raise httpx.ConnectError( + "connection reset", request=httpx.Request("DELETE", url) + ) + + async_transport = AsyncTransport.__new__(AsyncTransport) + async_transport._closed = True + async_transport.client = DummyAsyncClient() + + with pytest.raises(HyperbrowserError) as put_exc: + await async_transport.put( + "https://api.hyperbrowser.ai/api/session/s1/stop", timeout=15.0 + ) + assert put_exc.value.retryable is True + assert put_exc.value.service == "control" + assert "[PUT /api/session/s1/stop]" in str(put_exc.value) + + with pytest.raises(HyperbrowserError) as del_exc: + await async_transport.delete( + "https://api.hyperbrowser.ai/api/volume/v1", timeout=9.0 + ) + assert del_exc.value.retryable is True + assert del_exc.value.service == "control" + assert "[DELETE /api/volume/v1]" in str(del_exc.value) + assert recorded_timeouts == [ + ("PUT", "https://api.hyperbrowser.ai/api/session/s1/stop", 15.0), + ("DELETE", "https://api.hyperbrowser.ai/api/volume/v1", 9.0), + ] + + +@pytest.mark.anyio +async def test_handle_response_normalizes_request_error_with_metadata(): + request = httpx.Request("POST", "https://api.hyperbrowser.ai/api/session") + + class BrokenResponse: + status_code = 200 + headers = {"content-type": "application/json"} + + def __init__(self): + self.request = request + + def raise_for_status(self): + return None + + @property + def content(self): + raise httpx.ReadError("stream interrupted", request=request) + + sync_transport = SyncTransport.__new__(SyncTransport) + with pytest.raises(HyperbrowserError) as sync_exc: + sync_transport._handle_response(BrokenResponse()) + assert sync_exc.value.retryable is True + assert sync_exc.value.service == "control" + assert isinstance(sync_exc.value.cause, httpx.ReadError) + assert "[POST /api/session]" in str(sync_exc.value) + + async_transport = AsyncTransport.__new__(AsyncTransport) + async_transport._closed = True + with pytest.raises(HyperbrowserError) as async_exc: + await async_transport._handle_response(BrokenResponse()) + assert async_exc.value.retryable is True + assert async_exc.value.service == "control" + assert isinstance(async_exc.value.cause, httpx.ReadError) + assert "[POST /api/session]" in str(async_exc.value) + + +@pytest.mark.anyio +async def test_sandbox_hydrate_preserves_startup_secrets_and_removes_dead_helper(): + assert not hasattr(SandboxHandle, "_apply_runtime_session") + assert not hasattr(AsyncSandboxHandle, "_apply_runtime_session") + + initial_payload = { + **SANDBOX_DETAIL_PAYLOAD, + "startupSecrets": [ + { + "env": "API_TOKEN", + "id": "sec_1", + "name": "my-secret", + "version": 2, + } + ], + } + refreshed_payload = { + **SANDBOX_DETAIL_PAYLOAD, + "status": "active", + } + + sync_service = SimpleNamespace( + runtime_timeout=30, + runtime_proxy_override=None, + get_detail=lambda sandbox_id: SandboxDetail(**refreshed_payload), + ) + handle = SandboxHandle(sync_service, SandboxDetail(**initial_payload)) + assert handle.startup_secrets is not None + assert len(handle.startup_secrets) == 1 + assert handle.startup_secrets[0].env == "API_TOKEN" + + info = handle.info() + assert info.startup_secrets is not None + assert info.startup_secrets[0].env == "API_TOKEN" + assert handle.startup_secrets is not None + assert handle.startup_secrets[0].env == "API_TOKEN" + assert handle.to_dict()["startup_secrets"][0]["env"] == "API_TOKEN" + + async def async_get_detail(sandbox_id): + return SandboxDetail(**refreshed_payload) + + async_service = SimpleNamespace( + runtime_timeout=30, + runtime_proxy_override=None, + get_detail=async_get_detail, + ) + async_handle = AsyncSandboxHandle(async_service, SandboxDetail(**initial_payload)) + async_info = await async_handle.info() + assert async_info.startup_secrets is not None + assert async_info.startup_secrets[0].env == "API_TOKEN" + assert async_handle.startup_secrets is not None + assert async_handle.startup_secrets[0].env == "API_TOKEN" + + +@pytest.mark.anyio +async def test_sandbox_manager_url_encodes_path_parameters(): + build_payload = { + "build": { + "id": "build/1", + "imageName": "img", + "namespace": "team_1", + "status": "completed", + "createdAt": "2026-03-12T00:00:00Z", + "updatedAt": "2026-03-12T00:00:01Z", + } + } + + def make_handler(paths): + def handler(request: httpx.Request): + paths.append((request.method, request.url.raw_path.decode("ascii"))) + path = request.url.path + if path.startswith("/api/images/builds/"): + return httpx.Response(200, json=build_payload) + if path.startswith("/api/images/"): + return httpx.Response( + 200, + json={"id": "img_1", "imageName": "org/name:tag", "deleted": True}, + ) + if path.startswith("/api/snapshots/"): + if request.method == "DELETE": + return httpx.Response( + 200, + json={ + "id": "snap_1", + "snapshotName": "snap/name#1", + "deleted": True, + }, + ) + return httpx.Response( + 200, json={"snapshot": SNAPSHOT_LIST_PAYLOAD["snapshots"][0]} + ) + if path.endswith("/stop"): + return httpx.Response(200, json={"success": True}) + if path.endswith("/snapshot"): + return httpx.Response(200, json=SNAPSHOT_RESULT_PAYLOAD) + if path.endswith("/network"): + return httpx.Response( + 200, + json={ + "sandboxId": "sbx/1", + "network": { + "allowInternetAccess": True, + "allowOut": [], + "denyOut": [], + }, + }, + ) + if path.endswith("/expose"): + return httpx.Response( + 200, + json={ + "port": 3000, + "auth": False, + "url": "https://3000-sbx.runtime.example.com/", + }, + ) + if path.endswith("/unexpose"): + return httpx.Response(200, json={"port": 3000, "exposed": False}) + if path.endswith("/processes"): + return httpx.Response(200, json={"process": {"id": "proc_1"}}) + return httpx.Response(200, json=SANDBOX_DETAIL_PAYLOAD) + + return handler + + sync_paths = [] + client = Hyperbrowser.__new__(Hyperbrowser) + client.config = SimpleNamespace( + api_key="test", + base_url="https://api.hyperbrowser.ai", + runtime_proxy_override=None, + ) + client.timeout = 30 + client.transport = SyncTransport.__new__(SyncTransport) + client.transport.client = httpx.Client( + transport=httpx.MockTransport(make_handler(sync_paths)) + ) + from hyperbrowser.client.managers.sync_manager.sandbox import SandboxManager + + mgr = SandboxManager(client) + mgr.delete_image("org/image:tag") + mgr.get_snapshot("snap/1?x=2") + mgr.delete_snapshot("snap/1?x=2") + mgr.stop("sbx/1#a") + mgr.get_image_build("bld/1?y=2") + mgr.complete_image_build( + "bld/1?y=2", + { + "input_sha256": "a" * 64, + "input_size_bytes": 10, + "input_format": "docker_image_manifest_v1", + }, + ) + mgr.cancel_image_build("bld/1?y=2") + mgr.get_detail("sbx/1#a") + mgr.create_memory_snapshot("sbx/1#a") + mgr.update_network("sbx/1#a", {"allow_internet_access": True}) + mgr.expose("sbx/1#a", {"port": 3000}) + mgr.unexpose("sbx/1#a", 3000) + mgr.start_secret_process("sbx/1#a", {"command": "echo"}) + client.transport.close() + + expected = [ + ("DELETE", "/api/images/org%2Fimage%3Atag"), + ("GET", "/api/snapshots/snap%2F1%3Fx%3D2"), + ("DELETE", "/api/snapshots/snap%2F1%3Fx%3D2"), + ("PUT", "/api/sandbox/sbx%2F1%23a/stop"), + ("GET", "/api/images/builds/bld%2F1%3Fy%3D2"), + ("POST", "/api/images/builds/bld%2F1%3Fy%3D2/complete"), + ("POST", "/api/images/builds/bld%2F1%3Fy%3D2/cancel"), + ("GET", "/api/sandbox/sbx%2F1%23a"), + ("POST", "/api/sandbox/sbx%2F1%23a/snapshot"), + ("PUT", "/api/sandbox/sbx%2F1%23a/network"), + ("POST", "/api/sandbox/sbx%2F1%23a/expose"), + ("GET", "/api/sandbox/sbx%2F1%23a"), + ("POST", "/api/sandbox/sbx%2F1%23a/unexpose"), + ("POST", "/api/sandbox/sbx%2F1%23a/processes"), + ] + assert sync_paths == expected + + async_paths = [] + async_client = AsyncHyperbrowser.__new__(AsyncHyperbrowser) + async_client.config = SimpleNamespace( + api_key="test", + base_url="https://api.hyperbrowser.ai", + runtime_proxy_override=None, + ) + async_client.timeout = 30 + async_client.transport = AsyncTransport.__new__(AsyncTransport) + async_client.transport._closed = False + async_client.transport.client = httpx.AsyncClient( + transport=httpx.MockTransport(make_handler(async_paths)) + ) + from hyperbrowser.client.managers.async_manager.sandbox import ( + SandboxManager as AsyncSandboxManager, + ) + + async_mgr = AsyncSandboxManager(async_client) + await async_mgr.delete_image("org/image:tag") + await async_mgr.get_snapshot("snap/1?x=2") + await async_mgr.delete_snapshot("snap/1?x=2") + await async_mgr.stop("sbx/1#a") + await async_mgr.get_image_build("bld/1?y=2") + await async_mgr.complete_image_build( + "bld/1?y=2", + { + "input_sha256": "a" * 64, + "input_size_bytes": 10, + "input_format": "docker_image_manifest_v1", + }, + ) + await async_mgr.cancel_image_build("bld/1?y=2") + await async_mgr.get_detail("sbx/1#a") + await async_mgr.create_memory_snapshot("sbx/1#a") + await async_mgr.update_network("sbx/1#a", {"allow_internet_access": True}) + await async_mgr.expose("sbx/1#a", {"port": 3000}) + await async_mgr.unexpose("sbx/1#a", 3000) + await async_mgr.start_secret_process("sbx/1#a", {"command": "echo"}) + await async_client.transport.close() + + assert async_paths == expected + + +@pytest.mark.anyio +async def test_session_webgl_fingerprinting_solver_type_and_active_count(): + params = CreateSessionParams(enable_webgl_fingerprinting=True) + dumped = params.model_dump(by_alias=True, exclude_none=True) + assert dumped["enableWebglFingerprinting"] is True + + launch_state = SessionLaunchState( + solverType="future-solver-v2", enableWebglFingerprinting=True + ) + assert launch_state.solver_type == "future-solver-v2" + assert launch_state.enable_webgl_fingerprinting is True + + def handler(request: httpx.Request): + assert request.method == "GET" + assert request.url.path == "/api/sessions/active-count" + return httpx.Response( + 200, + json={ + "activeSessionsCount": 3, + }, + ) + + client = Hyperbrowser.__new__(Hyperbrowser) + client.config = SimpleNamespace( + api_key="test", base_url="https://api.hyperbrowser.ai" + ) + client.timeout = 30 + client.transport = SyncTransport.__new__(SyncTransport) + client.transport.client = httpx.Client(transport=httpx.MockTransport(handler)) + from hyperbrowser.client.managers.sync_manager.session import SessionManager + + session_mgr = SessionManager(client) + res = session_mgr.get_active_sessions_count() + assert res.active_sessions_count == 3 + client.transport.close() + + async_client = AsyncHyperbrowser.__new__(AsyncHyperbrowser) + async_client.config = SimpleNamespace( + api_key="test", base_url="https://api.hyperbrowser.ai" + ) + async_client.timeout = 30 + async_client.transport = AsyncTransport.__new__(AsyncTransport) + async_client.transport._closed = False + async_client.transport.client = httpx.AsyncClient( + transport=httpx.MockTransport(handler) + ) + from hyperbrowser.client.managers.async_manager.session import ( + SessionManager as AsyncSessionManager, + ) + + async_session_mgr = AsyncSessionManager(async_client) + async_res = await async_session_mgr.get_active_sessions_count() + assert async_res.active_sessions_count == 3 + await async_client.transport.close() + + +@pytest.mark.anyio +async def test_browser_use_tool_falls_back_to_error_and_credential_fill_validates_session_id(): + failed_response = BrowserUseTaskResponse( + jobId="job_1", + status="failed", + data=BrowserUseTaskData(steps=[], finalResult=None), + error="Task timed out", + ) + sync_hb = SimpleNamespace( + agents=SimpleNamespace( + browser_use=SimpleNamespace(start_and_wait=lambda params: failed_response) + ) + ) + assert tools.BrowserUseTool.runnable(sync_hb, {"task": "do something"}) == ( + "Task timed out" + ) + + async def async_start_and_wait(params): + return failed_response + + async_hb = SimpleNamespace( + agents=SimpleNamespace( + browser_use=SimpleNamespace(start_and_wait=async_start_and_wait) + ) + ) + assert ( + await tools.BrowserUseTool.async_runnable(async_hb, {"task": "do something"}) + == "Task timed out" + ) + + from hyperbrowser.client.managers.async_manager.session_credentials import ( + SessionCredentialsManager as AsyncSessionCredentialsManager, + ) + from hyperbrowser.client.managers.sync_manager.session_credentials import ( + SessionCredentialsManager, + ) + + sync_creds = SessionCredentialsManager(SimpleNamespace()) + for invalid_id in ("", " ", None): + with pytest.raises(HyperbrowserError, match="A session ID is required") as exc: + sync_creds.fill( + invalid_id, + {"credential": "my-secret", "fields": [{"selector": "#pw"}]}, + ) + assert exc.value.code == "invalid_request" + + async_creds = AsyncSessionCredentialsManager(SimpleNamespace()) + for invalid_id in ("", " ", None): + with pytest.raises(HyperbrowserError, match="A session ID is required") as exc: + await async_creds.fill( + invalid_id, + {"credential": "my-secret", "fields": [{"selector": "#pw"}]}, + ) + assert exc.value.code == "invalid_request"