grasp-sdk 0.1.9__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

grasp_sdk/services/browser.py

@@ -25,20 +25,20 @@ class CDPConnection:
         ws_url: str,
         http_url: str,
         port: int,
-        pid: Optional[int] = None
+        id: str,
     ):
         self.ws_url = ws_url
         self.http_url = http_url
         self.port = port
-        self.pid = pid
+        self.id = id
     
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary representation."""
         return {
+            'id': self.id,
             'wsUrl': self.ws_url,
             'httpUrl': self.http_url,
-            'port': self.port,
-            'pid': self.pid
+            'port': self.port
         }
 
 
@@ -77,6 +77,7 @@ class BrowserService:
         self.cdp_connection: Optional[CDPConnection] = None
         self.browser_process: Optional[CommandEventEmitter] = None
         self._health_check_task: Optional[asyncio.Task] = None
+        self.config['envs']['APIKEY'] = sandbox_config['key']
     
     def _get_default_logger(self):
         """Gets or creates a default logger instance."""
@@ -99,24 +100,54 @@ class BrowserService:
         """
         self.logger.info('Initializing Browser service')
         envs = {
-            'CDP_PORT': '9222',
             'BROWSER_ARGS': json.dumps(self.config['args']),
             'LAUNCH_TIMEOUT': str(self.config['launchTimeout']),
             'SANDBOX_TIMEOUT': str(self.sandbox_service.timeout),
             'HEADLESS': str(self.config['headless']).lower(),
             'NODE_ENV': 'production',
             # 'SANDBOX_ID': self.sandbox_service.id,
+            'PLAYWRIGHT_BROWSERS_PATH': '0',
             'WORKSPACE': self.sandbox_service.workspace,
-            'BS_SOURCE_TOKEN': 'Qth8JGboEKVersqr1PSsUFMW',
-            'BS_INGESTING_HOST': 's1363065.eu-nbg-2.betterstackdata.com',
-            'SENTRY_DSN': 'https://21fa729ceb72d7f0adef06b4f786c067@o4509574910509056.ingest.us.sentry.io/4509574913720320',
+            'BROWSER_TYPE': browser_type,
             **self.config['envs']
         }
-        await self.sandbox_service.create_sandbox(f'grasp-run-{browser_type}', envs)
-        if(self.sandbox_service.sandbox is not None):
-            await self.sandbox_service.sandbox.files.write('/home/user/.sandbox_id', self.id)
+        await self.sandbox_service.create_sandbox(f'grasp-run-{browser_type}-v2', envs)
+        # if(self.sandbox_service.sandbox is not None):
+        #     await self.sandbox_service.sandbox.files.write('/home/user/.sandbox_id', self.id)
         self.logger.info('Grasp sandbox initialized successfully')
     
+    async def connect(self, sandbox_id: str) -> CDPConnection:
+        """Connect to an existing sandbox.
+        
+        Args:
+            sandbox_id: ID of the sandbox to connect to
+            
+        Returns:
+            CDP connection information
+        """
+        self.logger.info('Initializing Browser service')
+        await self.sandbox_service.connect_sandbox(sandbox_id)
+        self.logger.info('Browser service initialized successfully')
+        
+        # Read CDP connection info from file
+        if not self.sandbox_service.sandbox:
+            raise RuntimeError('Sandbox is not available')
+        
+        cdp_content = await self.sandbox_service.sandbox.files.read(
+            '/home/user/.grasp-cdp.json'
+        )
+        cdp_data = json.loads(cdp_content)
+        
+        # Create CDPConnection object
+        self.cdp_connection = CDPConnection(
+            ws_url=cdp_data['wsUrl'],
+            http_url=cdp_data['httpUrl'],
+            port=cdp_data['port'],
+            id=cdp_data['id']
+        )
+        
+        return self.cdp_connection
+    
     async def launch_browser(
         self,
     ) -> CDPConnection:
@@ -174,15 +205,22 @@ class BrowserService:
             # Create CDP connection info
             self.cdp_connection = result
             
+            # Write CDP connection info to file
+            if not self.sandbox_service.sandbox:
+                raise RuntimeError('Sandbox is not available')
+            
+            await self.sandbox_service.sandbox.files.write(
+                '/home/user/.grasp-cdp.json',
+                json.dumps(self.cdp_connection.to_dict())
+            )
+            
             self.logger.info(
                 f'Chromium browser launched successfully (cdpPort: 9222, wsUrl: {self.cdp_connection.ws_url})'
             )
             
-            # Start health check if not in debug mode
-            if not self.sandbox_service.is_debug:
-                self._health_check_task = asyncio.create_task(
-                    self._start_health_check()
-                )
+            self._health_check_task = asyncio.create_task(
+                self._start_health_check()
+            )
             
             return self.cdp_connection
             
@@ -201,11 +239,11 @@ class BrowserService:
         def on_stderr(data: str) -> None:
             self.logger.info(f'Browser stderr: {data}')
         
-        def on_exit(exit_code: int) -> None:
-            self.logger.info(f'Browser process exited (exitCode: {exit_code})')
-            self.cdp_connection = None
-            self.browser_process = None
-            asyncio.create_task(self.sandbox_service.destroy())
+        # def on_exit(exit_code: int) -> None:
+        #     self.logger.info(f'Browser process exited (exitCode: {exit_code})')
+        #     self.cdp_connection = None
+        #     self.browser_process = None
+        #     asyncio.create_task(self.sandbox_service.destroy())
         
         def on_error(error: Exception) -> None:
             self.logger.error(f'Browser process error: {error}')
@@ -214,7 +252,7 @@ class BrowserService:
         if hasattr(self.browser_process, 'on'):
             self.browser_process.on('stdout', on_stdout)
             self.browser_process.on('stderr', on_stderr)
-            self.browser_process.on('exit', on_exit)
+            # self.browser_process.on('exit', on_exit)
             self.browser_process.on('error', on_error)
     
     async def _wait_for_cdp_ready(self) -> CDPConnection:
@@ -252,7 +290,7 @@ class BrowserService:
                                 ws_url = metadata['webSocketDebuggerUrl'].replace(
                                     'ws://', 'wss://'
                                 ).replace(
-                                    f'localhost:9222', host
+                                    '127.0.0.1:9222', host
                                 )
                                 
                                 http_url = f'https://{host}'
@@ -260,7 +298,8 @@ class BrowserService:
                                 connection = CDPConnection(
                                     ws_url=ws_url,
                                     http_url=http_url,
-                                    port=9222
+                                    port=9222,
+                                    id=str(self.sandbox_service.id)
                                 )
                                 
                                 self.logger.info(f'CDP server is ready (metadata: {metadata})')
@@ -338,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
@@ -347,8 +387,8 @@ class BrowserService:
             self.logger.info('Chromium browser stopped successfully')
             
         except Exception as error:
-            self.logger.error(f'Error stopping browser: {error}')
-            raise
+            self.logger.debug(f'Error stopping browser: {error}')
+            # raise
     
     async def cleanup(self) -> None:
         """Cleanup all resources including Grasp sandbox.

grasp_sdk/services/filesystem.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Filesystem service for managing file operations in sandbox.
+
+This module provides Python implementation of the filesystem service,
+equivalent to the TypeScript version in src/services/filesystem.service.ts
+"""
+
+import asyncio
+from typing import Optional, Dict, Union
+from ..utils.logger import get_logger, Logger
+from .sandbox import SandboxService
+from .browser import CDPConnection
+
+
+class FileSystemService:
+    """
+    Filesystem service for managing file operations in sandbox.
+    """
+    
+    def __init__(self, sandbox: SandboxService, connection: CDPConnection):
+        """Initialize filesystem service.
+        
+        Args:
+            sandbox: The sandbox service instance
+            connection: The CDP connection for browser integration
+        """
+        self.sandbox = sandbox
+        self.connection = connection
+        self.logger = self._get_default_logger()
+    
+    def _get_default_logger(self) -> Logger:
+        """Gets or creates a default logger instance.
+        
+        Returns:
+            Logger instance
+        """
+        try:
+            return get_logger().child('FileSystemService')
+        except Exception:
+            # If logger is not initialized, create a default one
+            from ..utils.logger import Logger
+            default_logger = Logger({
+                'level': 'debug' if self.sandbox.is_debug else 'info',
+                'console': True
+            })
+            return default_logger.child('FileSystemService')
+    
+    async def upload_file(self, local_path: str, remote_path: str) -> None:
+        """Upload file from local to sandbox.
+        
+        Args:
+            local_path: Local file path
+            remote_path: Remote file path in sandbox
+        """
+        upload_result = await self.sandbox.upload_file_to_sandbox(local_path, remote_path)
+        return upload_result
+    
+    async def download_file(self, remote_path: str, local_path: str) -> None:
+        """Download file from sandbox to local.
+        
+        Args:
+            remote_path: Remote file path in sandbox
+            local_path: Local file path
+        """
+        download_result = await self.sandbox.copy_file_from_sandbox(remote_path, local_path)
+        return download_result
+    
+    async def write_file(self, remote_path: str, content: Union[str, bytes]) -> None:
+        """Write content to file in sandbox.
+        
+        Args:
+            remote_path: Remote file path in sandbox
+            content: File content to write (string or bytes)
+        """
+        write_result = await self.sandbox.write_file_to_sandbox(remote_path, content)
+        return write_result
+    
+    async def read_file(
+        self, 
+        remote_path: str, 
+        options: Optional[Dict[str, str]] = None
+    ) -> Union[str, bytes]:
+        """Read content from file in sandbox.
+        
+        Args:
+            remote_path: Remote file path in sandbox
+            options: Dictionary with 'encoding' key ('utf8', 'base64', or 'binary')
+            
+        Returns:
+            File content as string or bytes depending on encoding
+        """
+        read_result = await self.sandbox.read_file_from_sandbox(remote_path, options)
+        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