grasp-sdk 0.2.0a1__tar.gz → 0.2.0b2__tar.gz

{grasp_sdk-0.2.0a1/grasp_sdk.egg-info → grasp_sdk-0.2.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_sdk
-Version: 0.2.0a1
+Version: 0.2.0b2
 Summary: Python SDK for Grasp E2B - Browser automation and sandbox management
 Home-page: https://github.com/grasp-team/grasp-e2b
 Author: Grasp Team

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/examples/example_async_context.py

@@ -31,7 +31,7 @@ async def example_with_context_manager():
             
             # 创建终端
             print("💻 创建终端...")
-            terminal = session.terminal.create()
+            terminal = session.terminal
             print(f"✅ 终端已创建: {type(terminal).__name__}")
             
             # 访问文件系统

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/examples/example_grasp_usage.py

@@ -34,7 +34,7 @@ async def example_grasp_usage():
         print(f"✓ Browser WebSocket endpoint: {browser_endpoint}")
         
         # Create terminal
-        terminal = session.terminal.create()
+        terminal = session.terminal
         print("✓ Terminal service created")
         
         # Access file system

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/examples/grasp_terminal.py

@@ -36,7 +36,8 @@ async def main():
                 # 'debug': True,
             },
             'keepAliveMS': 10000,
-            'timeout': 3600000,  # 容器最长运行1小时（最大值可以为一天 86400000）
+            # 'logLevel': 'error',
+            #'timeout': 3600000,  # 容器最长运行1小时（最大值可以为一天 86400000）
         })
 
         connection = session.browser.connection
@@ -44,7 +45,7 @@ async def main():
         
         # Create terminal connection
         print("📡 Creating terminal connection...")
-        terminal = session.terminal.create()
+        terminal = session.terminal
         
         print("✅ Terminal connected!")
         

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/examples/test_grasp_classes.py

@@ -2,7 +2,7 @@
 """测试 Grasp 类的功能"""
 
 import os
-from grasp_sdk import Grasp, GraspSession, GraspBrowser, GraspTerminal
+from grasp_sdk import Grasp, GraspSession, GraspBrowser
 
 def test_grasp_classes():
     """测试所有 Grasp 类的基本功能"""
@@ -25,7 +25,6 @@ def test_grasp_classes():
     print(f"   ✓ Grasp 类可用: {Grasp is not None}")
     print(f"   ✓ GraspSession 类可用: {GraspSession is not None}")
     print(f"   ✓ GraspBrowser 类可用: {GraspBrowser is not None}")
-    print(f"   ✓ GraspTerminal 类可用: {GraspTerminal is not None}")
     
     # 测试方法可用性
     print("\n3. 测试方法可用性:")

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/examples/test_removed_methods.py

@@ -17,7 +17,7 @@ def test_removed_methods():
     print("=" * 30)
     
     try:
-        from grasp_sdk import Grasp, GraspSession, GraspBrowser, GraspTerminal
+        from grasp_sdk import Grasp, GraspSession, GraspBrowser
         print("✅ 核心类导入成功")
     except ImportError as e:
         print(f"❌ 核心类导入失败: {e}")

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/examples/test_terminal_updates.py

@@ -111,7 +111,7 @@ async def test_terminal_service():
         mock_sandbox.run_command.return_value = mock_emitter
         
         # Test run_command
-        result = await terminal.run_command('echo "Hello World"', {'timeout': 5000})
+        result = await terminal.run_command('echo "Hello World"', {'timeout_ms': 5000})
         print("✓ run_command executed successfully")
         
         # Verify the command was called with correct options
@@ -152,7 +152,7 @@ async def test_command_options_compatibility():
     # Test that ICommandOptions supports 'inBackground' parameter
     options: ICommandOptions = {
         'inBackground': True,
-        'timeout': 5000,
+        'timeout_ms': 5000,
         'cwd': '/tmp',
         'nohup': False
     }

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/__init__.py

@@ -16,7 +16,6 @@ from .utils.logger import get_logger
 from .grasp import (
     GraspServer,
     GraspBrowser,
-    GraspTerminal,
     GraspSession,
     Grasp,
     _servers,
@@ -26,7 +25,7 @@ from .grasp import (
 # Import CDPConnection for type annotation
 from .services.browser import CDPConnection
 
-__version__ = "0.2.0a1"
+__version__ = "0.2.0b2"
 __author__ = "Grasp Team"
 __email__ = "team@grasp.dev"
 
@@ -177,7 +176,6 @@ default = {
     'Grasp': Grasp,
     'GraspSession': GraspSession,
     'GraspBrowser': GraspBrowser,
-    'GraspTerminal': GraspTerminal,
     'launch_browser': launch_browser,
     'shutdown': shutdown,
 }

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/grasp/__init__.py

@@ -4,7 +4,6 @@ from typing import Dict
 
 from .server import GraspServer
 from .browser import GraspBrowser
-from .terminal import GraspTerminal
 from .session import GraspSession
 from .index import Grasp
 from .utils import (
@@ -18,7 +17,6 @@ _servers: Dict[str, GraspServer] = _servers
 __all__ = [
     'GraspServer',
     'GraspBrowser', 
-    'GraspTerminal',
     'GraspSession',
     'Grasp',
     'shutdown',

grasp_sdk-0.2.0b2/grasp_sdk/grasp/browser.py

@@ -0,0 +1,162 @@
+"""GraspBrowser class for browser interface."""
+
+import aiohttp
+import os
+from typing import Optional, Dict, Any, TYPE_CHECKING
+
+from ..services.browser import CDPConnection
+
+if TYPE_CHECKING:
+    from .session import GraspSession
+
+
+class GraspBrowser:
+    """Browser interface for Grasp session."""
+    
+    def __init__(self, connection: CDPConnection, session: Optional['GraspSession'] = None):
+        """Initialize GraspBrowser.
+        
+        Args:
+            connection: CDP connection instance
+            session: GraspSession instance for accessing terminal and files services
+        """
+        self.connection = connection
+        self.session = session
+    
+    def get_host(self) -> str:
+        """Get browser host.
+        
+        Returns:
+            Host for browser connection
+        """
+        from urllib.parse import urlparse
+        return urlparse(self.connection.http_url).netloc
+    
+    def get_endpoint(self) -> str:
+        """Get browser WebSocket endpoint URL.
+        
+        Returns:
+            WebSocket URL for browser connection
+        """
+        return self.connection.ws_url
+    
+    async def get_current_page_target_info(self) -> Optional[Dict[str, Any]]:
+        """Get current page target information.
+        
+        Warning:
+            This method is experimental and may change or be removed in future versions.
+            Use with caution in production environments.
+        
+        Returns:
+            Dictionary containing target info and last screenshot, or None if failed
+        """
+        host = self.connection.http_url
+        api = f"{host}/api/page/info"
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(api) as response:
+                    if not response.ok:
+                        return None
+                    
+                    data = await response.json()
+                    page_info = data.get('pageInfo', {})
+                    last_screenshot = page_info.get('lastScreenshot')
+                    session_id = page_info.get('sessionId')
+                    targets = page_info.get('targets', {})
+                    target_id = page_info.get('targetId')
+                    page_loaded = page_info.get('pageLoaded')
+                    
+                    current_target = {}
+                    for target in targets.values():
+                        if target.get('targetId') == target_id:
+                            current_target = target
+                            break
+                    
+                    return {
+                        'targetId': target_id,
+                        'sessionId': session_id,
+                        'pageLoaded': page_loaded,
+                        **current_target,
+                        'lastScreenshot': last_screenshot,
+                        'targets': targets,
+                    }
+        except Exception:
+             return None
+    
+    async def download_replay_video(self, local_path: str) -> None:
+        """Download replay video from screenshots.
+        
+        Args:
+            local_path: Local path to save the video file
+            
+        Raises:
+            RuntimeError: If session is not available or video generation fails
+        """
+        if not self.session:
+            raise RuntimeError("Session is required for download_replay_video")
+        
+        # Create terminal instance
+        terminal = self.session.terminal
+        
+        # Generate file list for ffmpeg
+        command1 = await terminal.run_command(
+            "cd /home/user/downloads/grasp-screenshots && ls -1 | grep -v '^filelist.txt$' | sort | awk '{print \"file '\''\" $0 \"'\''\"}'> filelist.txt"
+        )
+        await command1.end()
+        
+        # Generate video using ffmpeg
+        command2 = await terminal.run_command(
+            "cd /home/user/downloads/grasp-screenshots && ffmpeg -r 25 -f concat -safe 0 -i filelist.txt -vsync vfr -pix_fmt yuv420p output.mp4"
+        )
+        await command2.end()
+        
+        # Determine final local path
+        if not local_path.endswith('.mp4'):
+            local_path = os.path.join(local_path, 'output.mp4')
+        
+        # Download the generated video file
+        await self.session.files.download_file(
+            '/home/user/downloads/grasp-screenshots/output.mp4',
+            local_path
+        )
+    
+    async def get_liveview_streaming_url(self) -> Optional[str]:
+        """Get liveview streaming URL.
+        
+        Returns:
+            Liveview streaming URL or None if not ready
+        """
+        host = self.connection.http_url
+        api = f"{host}/api/session/liveview/stream"
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(api) as response:
+                    if not response.ok:
+                        return None
+                    return api
+        except Exception:
+            return None
+    
+    async def get_liveview_page_url(self) -> Optional[str]:
+        """Get liveview page URL.
+        
+        Warning:
+            This method is experimental and may change or be removed in future versions.
+            Use with caution in production environments.
+        
+        Returns:
+            Liveview page URL or None if not ready
+        """
+        host = self.connection.http_url
+        api = f"{host}/api/session/liveview/preview"
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(api) as response:
+                    if not response.ok:
+                        return None
+                    return api
+        except Exception:
+            return None

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/grasp/index.py

@@ -5,6 +5,7 @@ from typing import Dict, Optional, Any
 
 from .server import GraspServer
 from .session import GraspSession
+from ..utils.config import get_config
 
 
 class Grasp:
@@ -32,12 +33,13 @@ class Grasp:
         Returns:
             GraspSession instance
         """
+        config = get_config()
         browser_options = options.get('browser', {})
-        browser_options['key'] = self.key
-        browser_options['keepAliveMS'] = options.get('keepAliveMS', 10000)
-        browser_options['timeout'] = options.get('timeout', 900000)
-        browser_options['debug'] = options.get('debug', False)
-        browser_options['logLevel'] = options.get('logLevel', 'info')
+        browser_options['key'] = self.key or config['sandbox']['key']
+        browser_options['keepAliveMS'] = options.get('keepAliveMS', config['sandbox']['keepAliveMs'])
+        browser_options['timeout'] = options.get('timeout', config['sandbox']['timeout'])
+        browser_options['debug'] = options.get('debug', config['sandbox']['debug'])
+        browser_options['logLevel'] = options.get('logLevel', config['logger']['level'])
         
         server = GraspServer(browser_options)
         cdp_connection = await server.create_browser_task()
@@ -116,7 +118,10 @@ class Grasp:
         
         if not cdp_connection:
             # Create new server with no timeout for existing sessions
-            server = GraspServer({'timeout': 0})
+            server = GraspServer({
+                'timeout': 0,
+                'key': self.key,
+            })
             cdp_connection = await server.connect_browser_task(session_id)
         
         return GraspSession(cdp_connection)

grasp_sdk-0.2.0b2/grasp_sdk/grasp/session.py

@@ -0,0 +1,146 @@
+"""GraspSession class for session management."""
+
+import asyncio
+import websockets
+from typing import Optional
+from .browser import GraspBrowser
+from ..services.terminal import TerminalService
+from ..services.browser import CDPConnection
+from ..services.filesystem import FileSystemService
+from ..utils.logger import get_logger
+
+
+class GraspSession:
+    """Main session interface providing access to browser, terminal, and files."""
+    
+    def __init__(self, connection: CDPConnection):
+        """Initialize GraspSession.
+        
+        Args:
+            connection: CDP connection instance
+        """
+        self.connection = connection
+        self.browser = GraspBrowser(connection, self)
+        
+        # Create files service
+        connection_id = connection.id
+        try:
+            from .utils import _servers
+            server = _servers[connection_id]
+            if server.sandbox is None:
+                raise RuntimeError('Sandbox is not available for file system service')
+            self.files = FileSystemService(server.sandbox, connection)
+            self.terminal = TerminalService(server.sandbox, connection)
+        except (ImportError, KeyError) as e:
+            # In test environment or when server is not available, create a mock files service
+            self.logger.debug(f"Warning: Files service not available: {e}")
+            raise e
+        
+        # WebSocket connection for keep-alive
+        self._ws = None
+        self._is_closed = False
+
+        self.logger = get_logger().child('GraspSession')
+        
+        # Initialize WebSocket connection and start keep-alive
+        # self.logger.debug('create session...')
+        asyncio.create_task(self._initialize_websocket())
+    
+    async def _initialize_websocket(self) -> None:
+        """Initialize WebSocket connection and start keep-alive."""
+        try:
+            self._ws = await websockets.connect(self.connection.ws_url)
+            if not self._is_closed:
+                await self._keep_alive()
+            else:
+                await self._ws.close()
+        except Exception as e:
+            self.logger.debug(f"Failed to initialize WebSocket connection: {e}")
+    
+    async def _keep_alive(self) -> None:
+        """Keep WebSocket connection alive with periodic ping."""
+        ws = self._ws
+        await asyncio.sleep(10)  # 10 seconds interval, same as TypeScript version
+        if ws and ws.close_code is None:
+            try:
+                # Send ping and wait for pong response
+                pong_waiter = ws.ping()
+                await pong_waiter
+                # Recursively call keep_alive after receiving pong
+                await self._keep_alive()
+            except Exception as e:
+                self.logger.debug(f"Keep-alive ping failed: {e}")
+    
+    @property
+    def id(self) -> str:
+        """Get session ID.
+        
+        Returns:
+            Session ID
+        """
+        return self.connection.id
+    
+    def is_running(self) -> bool:
+        """Check if the session is currently running.
+        
+        Returns:
+            True if the session is running, False otherwise
+        """
+        try:
+            from .utils import _servers
+            from ..models import SandboxStatus
+            server = _servers[self.id]
+            if server.sandbox is None:
+                return False
+            status = server.sandbox.get_status()
+            return status == SandboxStatus.RUNNING
+        except (ImportError, KeyError) as e:
+            self.logger.error(f"Failed to check running status: {e}")
+            return False
+    
+    def get_host(self, port: int) -> Optional[str]:
+        """Get the external host address for a specific port.
+        
+        Args:
+            port: Port number to get host for
+            
+        Returns:
+            External host address or None if sandbox not available
+        """
+        try:
+            from .utils import _servers
+            server = _servers[self.id]
+            if server.sandbox is None:
+                self.logger.warn('Cannot get host: sandbox not available')
+                return None
+            return server.sandbox.get_sandbox_host(port)
+        except (ImportError, KeyError) as e:
+            self.logger.error(f"Failed to get host: {e}")
+            return None
+    
+    async def close(self) -> None:
+        """Close the session and cleanup resources."""
+        # Set closed flag to prevent new keep-alive cycles
+        self._is_closed = True
+        
+        # Close WebSocket connection with timeout
+        if self._ws and self._ws.close_code is None:
+            try:
+                # Add timeout to prevent hanging on close
+                await asyncio.wait_for(self._ws.close(), timeout=5.0)
+                self.logger.debug('✅ WebSocket closed successfully')
+            except asyncio.TimeoutError:
+                self.logger.debug('⚠️ WebSocket close timeout, forcing termination')
+                # Force close if timeout
+                if hasattr(self._ws, 'transport') and self._ws.transport:
+                    self._ws.transport.close()
+            except Exception as e:
+                self.logger.error(f"Failed to close WebSocket connection: {e}")
+        
+        # Cleanup server resources
+        try:
+            from .utils import _servers
+            await _servers[self.id].cleanup()
+        except (ImportError, KeyError) as e:
+            # In test environment or when server is not available, skip cleanup
+            self.logger.error(f"Warning: Server cleanup not available: {e}")

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/models/__init__.py

@@ -23,6 +23,7 @@ class ISandboxConfig(TypedDict):
     timeout: int  # Required: Default timeout in milliseconds
     workspace: NotRequired[str]  # Optional: Grasp workspace ID
     debug: NotRequired[bool]  # Optional: Enable debug mode for detailed logging
+    keepAliveMs: NotRequired[int]  # Optional: Keep-alive time in milliseconds
     
 
 class IBrowserConfig(TypedDict):
@@ -35,19 +36,23 @@ class IBrowserConfig(TypedDict):
 
 class ICommandOptions(TypedDict):
     """Command execution options interface."""
-    inBackground: NotRequired[bool]  # Whether to run command in background
-    timeout: NotRequired[int]  # Timeout in milliseconds
+    inBackground: NotRequired[bool]  # Whether to run command in background (corresponds to 'background' in TypeScript)
+    timeout_ms: NotRequired[int]  # Timeout in milliseconds (corresponds to 'timeoutMs' in TypeScript)
     cwd: NotRequired[str]  # Working directory
-    nohup: NotRequired[bool]  # Whether to use nohup for command execution
+    user: NotRequired[str]  # User to run the command as (default: 'user')
+    envs: NotRequired[Dict[str, str]]  # Environment variables for the command
+    nohup: NotRequired[bool]  # Whether to use nohup for command execution (Grasp-specific extension)
+    # Note: onStdout and onStderr callbacks are handled differently in Python implementation
     
 
 class IScriptOptions(TypedDict):
     """Script execution options interface."""
     type: str  # Required: Script type: 'cjs' for CommonJS, 'esm' for ES Modules, 'py' for Python
     cwd: NotRequired[str]  # Working directory
-    timeoutMs: NotRequired[int]  # Timeout in milliseconds
+    timeout_ms: NotRequired[int]  # Timeout in milliseconds
     background: NotRequired[bool]  # Run in background
-    nohup: NotRequired[bool]  # Use nohup for background execution
+    user: NotRequired[str]  # User to run the script as (default: 'user')
+    nohup: NotRequired[bool]  # Use nohup for background execution (Grasp-specific extension)
     envs: NotRequired[Dict[str, str]]  # The environment variables
     preCommand: NotRequired[str]  # Pre command
 

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/services/browser.py

@@ -106,6 +106,7 @@ class BrowserService:
             'HEADLESS': str(self.config['headless']).lower(),
             'NODE_ENV': 'production',
             # 'SANDBOX_ID': self.sandbox_service.id,
+            'PLAYWRIGHT_BROWSERS_PATH': '0',
             'WORKSPACE': self.sandbox_service.workspace,
             'BROWSER_TYPE': browser_type,
             **self.config['envs']
@@ -185,7 +186,7 @@ class BrowserService:
                 'type': 'esm',
                 'background': True,
                 'nohup': not self.sandbox_service.is_debug,
-                'timeoutMs': 0,
+                'timeout_ms': 0,
                 'preCommand': ''
             }
             
@@ -376,8 +377,9 @@ class BrowserService:
                 self._health_check_task = None
             
             # Kill the browser process
-            # if hasattr(self.browser_process, 'kill'):
-            #     await self.browser_process.kill()
+            if self.browser_process is not None:
+                if hasattr(self.browser_process, 'kill'):
+                    await self.browser_process.kill()
             
             self.browser_process = None
             self.cdp_connection = None

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/services/filesystem.py

@@ -91,4 +91,33 @@ class FileSystemService:
             File content as string or bytes depending on encoding
         """
         read_result = await self.sandbox.read_file_from_sandbox(remote_path, options)
-        return read_result
+        return read_result
+    
+    async def sync_downloads_directory(
+        self,
+        local_path: str,
+        remote_path: Optional[str] = None
+    ) -> str:
+        """Synchronize downloads directory from sandbox to local filesystem.
+        
+        This method is experimental and may change or be removed in future versions.
+        Use with caution in production environments.
+        
+        Args:
+            local_path: Local directory path to sync to
+            remote_path: Remote directory path to sync from (defaults to local_path)
+            
+        Returns:
+            Local sync directory path
+            
+        Raises:
+            RuntimeError: If sandbox is not running or sync fails
+        """
+        if remote_path is None:
+            remote_path = local_path
+            
+        sync_result = await self.sandbox.sync_downloads_directory(
+            dist=local_path,
+            src=remote_path
+        )
+        return sync_result

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/services/sandbox.py

@@ -42,6 +42,8 @@ class CommandEventEmitter:
     def set_handle(self, handle: Any) -> None:
         """Set the command handle (used internally)."""
         self.handle = handle
+        if self.is_killed:
+            self.handle.kill()
     
     def on(self, event: str, callback: Callable) -> None:
         """Register event listener."""
@@ -98,9 +100,9 @@ class CommandEventEmitter:
     
     async def kill(self) -> None:
         """Kill the running command."""
-        if not self.handle:
-            raise RuntimeError('Command handle not set')
-        await self.handle.kill()
+        self.is_killed = True
+        if self.handle:
+            await self.handle.kill()
     
     def get_handle(self) -> Optional[Any]:
         """Get the original command handle."""
@@ -284,10 +286,11 @@ class SandboxService:
             options = {}
         
         cwd = options.get('cwd', self.DEFAULT_WORKING_DIRECTORY)
-        timeout_ms = options.get('timeout', self.config['timeout'])
+        timeout_ms = options.get('timeout_ms', 0)
         use_nohup = options.get('nohup', False)
         in_background = options.get('inBackground', False)
         envs = options.get('envs', {})
+        user = options.get('user', 'user')
 
         # print(f'command: {command}')
         # print(f'🚀 options {options}')
@@ -316,9 +319,10 @@ class SandboxService:
                     result = await self.sandbox.commands.run(
                         final_command,
                         cwd=cwd,
-                        timeout=timeout_ms,
+                        timeout=timeout_ms // 1000,
                         envs=envs,
                         background=in_background,
+                        user=user,
                     )
                 else:
                     raise RuntimeError('Sandbox commands interface not available')
@@ -344,6 +348,7 @@ class SandboxService:
                         timeout=timeout_ms // 1000,
                         envs=envs,
                         background=in_background,
+                        user=user,
                     )
                     return None
 
@@ -363,6 +368,7 @@ class SandboxService:
                                 timeout=timeout_ms // 1000,
                                 background=True,
                                 envs=envs,
+                                user=user,
                                 on_stdout=lambda data: event_emitter.emit('stdout', data),
                                 on_stderr=lambda data: event_emitter.emit('stderr', data)
                             )
@@ -467,10 +473,11 @@ class SandboxService:
             # Prepare command options
             cmd_options: Optional[Any] = {
                 'cwd': options.get('cwd'),
-                'timeout': options.get('timeoutMs'),
+                'timeout_ms': options.get('timeout_ms', 0),
                 'inBackground': options.get('background', False),
                 'nohup': options.get('nohup', False),
                 'envs': envs,
+                'user': options.get('user', 'user'),
             }
             
             # Execute the script
@@ -858,7 +865,7 @@ class SandboxService:
             raise ValueError(error_msg)
         
         remote_path = src
-        local_path = os.path.join(dist, str(self.id), str(int(time.time() * 1000)))
+        local_path = dist
         
         try:
             self.logger.debug('🗂️ Starting recursive directory sync', {

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/services/terminal.py

@@ -138,6 +138,11 @@ class Commands:
             # Force background execution for streaming
             bg_options: ICommandOptions = {**options, 'inBackground': True, 'nohup': False}
             
+            # Set browser endpoint in environment variables
+            if 'envs' not in bg_options:
+                bg_options['envs'] = {}
+            bg_options['envs']['BROWSER_ENDPOINT'] = self.connection.ws_url
+            
             emitter: Optional[CommandEventEmitter] = await self.sandbox.run_command(
                 command, bg_options
             )

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/utils/__init__.py

@@ -4,7 +4,7 @@ This package contains utility functions and classes for configuration,
 logging, authentication, and other common functionality."""
 
 # Import all utility modules
-from .config import get_config, get_sandbox_config, get_browser_config, DEFAULT_CONFIG
+from .config import get_config, get_sandbox_config, DEFAULT_CONFIG
 from .logger import Logger, init_logger, get_logger, debug, info, warn, error
 from .auth import verify, login, AuthError, KeyVerificationError, AuthManager
 
@@ -12,7 +12,6 @@ __all__ = [
     # Configuration
     'get_config',
     'get_sandbox_config', 
-    'get_browser_config',
     'DEFAULT_CONFIG',
     # Logging
     'Logger',

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk/utils/config.py

@@ -25,9 +25,10 @@ def get_config() -> Dict[str, Any]:
             'key': os.getenv('GRASP_KEY', ''),
             'timeout': int(os.getenv('GRASP_SERVICE_TIMEOUT', '900000')),
             'debug': os.getenv('GRASP_DEBUG', 'false').lower() == 'true',
+            'keepAliveMs': int(os.getenv('GRASP_KEEP_ALIVE_MS', '10000')),
         },
         'logger': {
-            'level': os.getenv('GRASP_LOG_LEVEL', 'info'),
+            'level': os.getenv('GRASP_LOG_LEVEL', None),
             'console': True,
             'file': os.getenv('GRASP_LOG_FILE'),
         },
@@ -54,40 +55,9 @@ def get_sandbox_config() -> ISandboxConfig:
     
     return sandbox_config
 
-
-def get_browser_config() -> IBrowserConfig:
-    """Gets browser-specific configuration.
-    
-    Returns:
-        IBrowserConfig: Browser configuration object.
-    """
-    return IBrowserConfig(
-        args=[
-            '--no-sandbox',
-            '--disable-setuid-sandbox',
-            '--disable-dev-shm-usage',
-            '--disable-gpu',
-            '--remote-debugging-port=9222',
-            '--remote-debugging-address=0.0.0.0',
-        ],
-        headless=os.getenv('GRASP_HEADLESS', 'true').lower() == 'true',
-        launchTimeout=int(os.getenv('GRASP_LAUNCH_TIMEOUT', '30000')),
-        envs={
-            'PLAYWRIGHT_BROWSERS_PATH': '0',
-            'DISPLAY': ':99',
-        },
-    )
-
-
 # Default configuration constants
 DEFAULT_CONFIG = {
-    'PLAYWRIGHT_BROWSERS_PATH': '0',
     'WORKING_DIRECTORY': '/home/user',
-    'SCREENSHOT_PATH': '/home/user',
-    'DEFAULT_VIEWPORT': {
-        'width': 1280,
-        'height': 720,
-    },
 }
 
 

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2/grasp_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_sdk
-Version: 0.2.0a1
+Version: 0.2.0b2
 Summary: Python SDK for Grasp E2B - Browser automation and sandbox management
 Home-page: https://github.com/grasp-team/grasp-e2b
 Author: Grasp Team

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/grasp_sdk.egg-info/SOURCES.txt

@@ -15,11 +15,9 @@ setup.py
 ./examples/grasp_terminal.py
 ./examples/grasp_usage.py
 ./examples/test_async_context.py
-./examples/test_get_replay_screenshots.py
 ./examples/test_grasp_classes.py
 ./examples/test_python_script.py
 ./examples/test_removed_methods.py
-./examples/test_shutdown_deprecation.py
 ./examples/test_terminal_updates.py
 ./grasp_sdk/__init__.py
 ./grasp_sdk/grasp/__init__.py
@@ -27,7 +25,6 @@ setup.py
 ./grasp_sdk/grasp/index.py
 ./grasp_sdk/grasp/server.py
 ./grasp_sdk/grasp/session.py
-./grasp_sdk/grasp/terminal.py
 ./grasp_sdk/grasp/utils.py
 ./grasp_sdk/models/__init__.py
 ./grasp_sdk/services/__init__.py
@@ -46,11 +43,9 @@ examples/example_readfile_usage.py
 examples/grasp_terminal.py
 examples/grasp_usage.py
 examples/test_async_context.py
-examples/test_get_replay_screenshots.py
 examples/test_grasp_classes.py
 examples/test_python_script.py
 examples/test_removed_methods.py
-examples/test_shutdown_deprecation.py
 examples/test_terminal_updates.py
 grasp_sdk/__init__.py
 grasp_sdk.egg-info/PKG-INFO
@@ -65,7 +60,6 @@ grasp_sdk/grasp/browser.py
 grasp_sdk/grasp/index.py
 grasp_sdk/grasp/server.py
 grasp_sdk/grasp/session.py
-grasp_sdk/grasp/terminal.py
 grasp_sdk/grasp/utils.py
 grasp_sdk/models/__init__.py
 grasp_sdk/services/__init__.py

{grasp_sdk-0.2.0a1 → grasp_sdk-0.2.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "grasp_sdk"
-version = "0.2.0a1"
+version = "0.2.0b2"
 authors = [
     {name = "Grasp Team", email = "team@grasp.com"},
 ]

grasp_sdk-0.2.0a1/examples/test_get_replay_screenshots.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-"""测试 get_replay_screenshots 功能的示例脚本
-
-这个脚本演示如何使用 get_replay_screenshots 函数获取截图目录路径。
-"""
-
-import asyncio
-import os
-from grasp_sdk import launch_browser, get_replay_screenshots
-
-
-async def test_get_replay_screenshots():
-    """测试 get_replay_screenshots 功能"""
-    print("🚀 启动浏览器服务...")
-    
-    try:
-        # 启动浏览器并获取连接信息
-        connection = await launch_browser({
-            'headless': True,
-            'type': 'chromium'
-        })
-        
-        print(f"✅ 浏览器启动成功!")
-        print(f"连接 ID: {connection.id}")
-        print(f"WebSocket URL: {connection.ws_url or connection.ws_url}")
-        print(f"HTTP URL: {connection.http_url}")
-        
-        # 获取截图目录路径
-        print("\n📸 获取截图目录路径...")
-        screenshots_dir = await get_replay_screenshots(connection)
-        
-        print(f"✅ 截图目录路径: {screenshots_dir}")
-        
-        # 检查目录是否存在
-        if os.path.exists(screenshots_dir):
-            print(f"📁 目录已存在")
-            
-            # 列出目录中的文件
-            files = os.listdir(screenshots_dir)
-            if files:
-                print(f"📋 目录中有 {len(files)} 个文件:")
-                for file in files[:5]:  # 只显示前5个文件
-                    print(f"  - {file}")
-                if len(files) > 5:
-                    print(f"  ... 还有 {len(files) - 5} 个文件")
-            else:
-                print("📂 目录为空")
-        else:
-            print(f"⚠️  目录不存在，将在首次使用时创建")
-        
-        # 测试错误处理
-        print("\n🧪 测试错误处理...")
-        
-        # 测试缺少 id 字段的情况
-        try:
-            invalid_connection = {
-                'ws_url': connection.ws_url,
-                'http_url': connection.http_url
-                # 缺少 'id' 字段
-            }
-            await get_replay_screenshots(invalid_connection)
-        except ValueError as e:
-            print(f"✅ 正确捕获 ValueError: {e}")
-        
-        # 测试无效 ID 的情况
-        try:
-            invalid_connection = {
-                'id': 'invalid-id-123',
-                'ws_url': connection.ws_url,
-                'http_url': connection.http_url
-            }
-            await get_replay_screenshots(invalid_connection)
-        except KeyError as e:
-            print(f"✅ 正确捕获 KeyError: {e}")
-        
-        print("\n🎉 所有测试完成!")
-        
-    except Exception as e:
-        print(f"❌ 测试失败: {e}")
-        raise
-
-
-if __name__ == "__main__":
-    # 检查环境变量
-    if not os.getenv('GRASP_KEY'):
-        print("⚠️  警告: 未设置 GRASP_KEY 环境变量")
-        print("请设置: export GRASP_KEY=your_api_key")
-    
-    # 运行测试
-    asyncio.run(test_get_replay_screenshots())

grasp_sdk-0.2.0a1/examples/test_shutdown_deprecation.py

@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-"""
-测试 shutdown 方法的废弃警告
-"""
-
-import warnings
-import sys
-import os
-
-# 添加项目路径
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from grasp_sdk import shutdown
-
-def test_shutdown_deprecation():
-    """测试 shutdown 方法是否正确发出废弃警告"""
-    print("🧪 测试 shutdown 方法的废弃警告...")
-    
-    # 设置警告过滤器显示所有警告
-    warnings.filterwarnings("always")
-    
-    # 捕获警告
-    with warnings.catch_warnings(record=True) as w:
-        warnings.simplefilter("always")
-        
-        print("📞 调用 shutdown(None)...")
-        
-        # 调用废弃的 shutdown 方法
-        try:
-            shutdown(None)
-            print("✅ shutdown 方法调用完成")
-        except SystemExit:
-            print("⚠️  shutdown 方法触发了系统退出")
-        except Exception as e:
-            print(f"⚠️  shutdown 方法调用出现异常: {e}")
-        
-        # 检查是否有废弃警告
-        print(f"\n📊 捕获到 {len(w)} 个警告")
-        deprecation_warnings = [warning for warning in w if issubclass(warning.category, DeprecationWarning)]
-        
-        if deprecation_warnings:
-            print(f"✅ 检测到 {len(deprecation_warnings)} 个废弃警告:")
-            for warning in deprecation_warnings:
-                print(f"   - {warning.message}")
-                print(f"     文件: {warning.filename}:{warning.lineno}")
-        else:
-            print("❌ 未检测到废弃警告")
-            if w:
-                print("其他警告:")
-                for warning in w:
-                    print(f"   - {warning.category.__name__}: {warning.message}")
-    
-    print("\n📋 废弃方法迁移指南:")
-    print("   旧方式: shutdown(connection)")
-    print("   新方式: await session.close()")
-    print("\n💡 建议:")
-    print("   - 使用 grasp.launch() 获取 session")
-    print("   - 使用 await session.close() 关闭会话")
-    print("   - 避免直接使用 shutdown() 方法")
-
-if __name__ == '__main__':
-    test_shutdown_deprecation()

grasp_sdk-0.2.0a1/grasp_sdk/grasp/browser.py

@@ -1,69 +0,0 @@
-"""GraspBrowser class for browser interface."""
-
-import aiohttp
-from typing import Optional, Dict, Any
-
-from ..services.browser import CDPConnection
-
-
-class GraspBrowser:
-    """Browser interface for Grasp session."""
-    
-    def __init__(self, connection: CDPConnection):
-        """Initialize GraspBrowser.
-        
-        Args:
-            connection: CDP connection instance
-        """
-        self.connection = connection
-    
-    def get_endpoint(self) -> str:
-        """Get browser WebSocket endpoint URL.
-        
-        Returns:
-            WebSocket URL for browser connection
-        """
-        return self.connection.ws_url
-    
-    async def get_current_page_target_info(self) -> Optional[Dict[str, Any]]:
-        """Get current page target information.
-        
-        Warning:
-            This method is experimental and may change or be removed in future versions.
-            Use with caution in production environments.
-        
-        Returns:
-            Dictionary containing target info and last screenshot, or None if failed
-        """
-        host = self.connection.http_url
-        api = f"{host}/api/page/info"
-        
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(api) as response:
-                    if not response.ok:
-                        return None
-                    
-                    data = await response.json()
-                    page_info = data.get('pageInfo', {})
-                    last_screenshot = page_info.get('lastScreenshot')
-                    session_id = page_info.get('sessionId')
-                    targets = page_info.get('targets', {})
-                    
-                    if session_id and session_id in targets:
-                        target_info = targets[session_id].copy()
-                        target_info['lastScreenshot'] = last_screenshot
-                        return target_info
-                    
-                    return None
-        except Exception:
-            return None
-    
-    def get_liveview_url(self) -> Optional[str]:
-        """Get liveview URL (TODO: implementation pending).
-        
-        Returns:
-            Liveview URL or None
-        """
-        # TODO: Implement liveview URL generation
-        return None

grasp_sdk-0.2.0a1/grasp_sdk/grasp/session.py

@@ -1,108 +0,0 @@
-"""GraspSession class for session management."""
-
-import asyncio
-import websockets
-from .browser import GraspBrowser
-from .terminal import GraspTerminal
-from ..services.browser import CDPConnection
-from ..services.filesystem import FileSystemService
-
-
-class GraspSession:
-    """Main session interface providing access to browser, terminal, and files."""
-    
-    def __init__(self, connection: CDPConnection):
-        """Initialize GraspSession.
-        
-        Args:
-            connection: CDP connection instance
-        """
-        self.connection = connection
-        self.browser = GraspBrowser(connection)
-        self.terminal = GraspTerminal(connection)
-        
-        # Create files service
-        connection_id = connection.id
-        try:
-            from . import _servers
-            server = _servers[connection_id]
-            if server.sandbox is None:
-                raise RuntimeError('Sandbox is not available for file system service')
-            self.files = FileSystemService(server.sandbox, connection)
-        except (ImportError, KeyError) as e:
-            # In test environment or when server is not available, create a mock files service
-            print(f"Warning: Files service not available: {e}")
-            raise e
-        
-        # WebSocket connection for keep-alive
-        self._ws = None
-        self._keep_alive_task = None
-        
-        # Initialize WebSocket connection and start keep-alive
-        print('create session...')
-        asyncio.create_task(self._initialize_websocket())
-    
-    async def _initialize_websocket(self) -> None:
-        """Initialize WebSocket connection and start keep-alive."""
-        try:
-            self._ws = await websockets.connect(self.connection.ws_url)
-            await self._keep_alive()
-        except Exception as e:
-            print(f"Failed to initialize WebSocket connection: {e}")
-    
-    async def _keep_alive(self) -> None:
-        """Keep WebSocket connection alive with periodic ping."""
-        if self._ws is None:
-            return
-            
-        async def ping_loop():
-            while self._ws and self._ws.close_code is None:
-                try:
-                    await self._ws.ping()
-                    await asyncio.sleep(10)  # 10 seconds interval, same as TypeScript version
-                except Exception as e:
-                    print(f"Keep-alive ping failed: {e}")
-                    break
-        
-        self._keep_alive_task = asyncio.create_task(ping_loop())
-    
-    @property
-    def id(self) -> str:
-        """Get session ID.
-        
-        Returns:
-            Session ID
-        """
-        return self.connection.id
-    
-    async def close(self) -> None:
-        """Close the session and cleanup resources."""
-        # Stop keep-alive task
-        if self._keep_alive_task:
-            self._keep_alive_task.cancel()
-            try:
-                await self._keep_alive_task
-            except asyncio.CancelledError:
-                pass
-        
-        # Close WebSocket connection with timeout
-        if self._ws and self._ws.close_code is None:
-            try:
-                # Add timeout to prevent hanging on close
-                await asyncio.wait_for(self._ws.close(), timeout=5.0)
-                print('✅ WebSocket closed successfully')
-            except asyncio.TimeoutError:
-                print('⚠️ WebSocket close timeout, forcing termination')
-                # Force close if timeout
-                if hasattr(self._ws, 'transport') and self._ws.transport:
-                    self._ws.transport.close()
-            except Exception as e:
-                print(f"Failed to close WebSocket connection: {e}")
-        
-        # Cleanup server resources
-        try:
-            from . import _servers
-            await _servers[self.id].cleanup()
-        except (ImportError, KeyError) as e:
-            # In test environment or when server is not available, skip cleanup
-            print(f"Warning: Server cleanup not available: {e}")

grasp_sdk-0.2.0a1/grasp_sdk/grasp/terminal.py

@@ -1,32 +0,0 @@
-"""GraspTerminal class for terminal interface."""
-
-from ..services.browser import CDPConnection
-from ..services.terminal import TerminalService
-
-
-class GraspTerminal:
-    """Terminal interface for Grasp session."""
-    
-    def __init__(self, connection: CDPConnection):
-        """Initialize GraspTerminal.
-        
-        Args:
-            connection: CDP connection instance
-        """
-        self.connection = connection
-    
-    def create(self) -> TerminalService:
-        """Create a new terminal service instance.
-        
-        Returns:
-            TerminalService instance
-            
-        Raises:
-            RuntimeError: If sandbox is not available
-        """
-        connection_id = self.connection.id
-        from . import _servers
-        server = _servers[connection_id]
-        if server.sandbox is None:
-            raise RuntimeError('Sandbox is not available')
-        return TerminalService(server.sandbox, self.connection)