grasp-sdk 0.1.8__py3-none-any.whl → 0.2.0a1__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,7 +100,6 @@ 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),
@@ -107,16 +107,46 @@ class BrowserService:
             'NODE_ENV': 'production',
             # 'SANDBOX_ID': self.sandbox_service.id,
             '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:
@@ -147,7 +177,7 @@ class BrowserService:
             # except FileNotFoundError:
             #     raise RuntimeError(f'Browser script not found: {script_path}')
 
-            playwright_script = '/home/user/http-proxy.mjs'
+            playwright_script = '/home/user/http-proxy.js'
             
             # Prepare script options
             from ..models import IScriptOptions
@@ -156,7 +186,7 @@ class BrowserService:
                 'background': True,
                 'nohup': not self.sandbox_service.is_debug,
                 'timeoutMs': 0,
-                'preCommand': '' if self.config['headless'] else 'xvfb-run -a -s "-screen 0 1280x1024x24" '
+                'preCommand': ''
             }
             
             # Run the Playwright script in background
@@ -174,15 +204,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 +238,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 +251,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:
@@ -226,7 +263,7 @@ class BrowserService:
         Raises:
             RuntimeError: If CDP server fails to become ready within timeout
         """
-        delay_ms = 100
+        delay_ms = 50
         max_attempts = self.config['launchTimeout'] // delay_ms
         
         for attempt in range(1, max_attempts + 1):
@@ -240,40 +277,32 @@ class BrowserService:
                 )
                 
                 # Check if CDP endpoint is responding
-                options: ICommandOptions = {
-                    'timeout': 0,
-                    'inBackground': False
-                }
-                result = await self.sandbox_service.run_command(
-                    f'curl -s https://{host}/json/version',
-                    options,
-                    True,
-                )
-                
-                if (
-                    getattr(result, 'exit_code', None) == 0 and 
-                    'Browser' in getattr(result, 'stdout', '')
-                ):
-                    stdout_content = getattr(result, 'stdout', '')
-                    metadata = json.loads(stdout_content)
-                    
-                    # Update URLs for external access
-                    ws_url = metadata['webSocketDebuggerUrl'].replace(
-                        'ws://', 'wss://'
-                    ).replace(
-                        f'localhost:9222', host
-                    )
-                    
-                    http_url = f'https://{host}'
-                    
-                    connection = CDPConnection(
-                        ws_url=ws_url,
-                        http_url=http_url,
-                        port=9222
-                    )
-                    
-                    self.logger.info(f'CDP server is ready (metadata: {metadata})')
-                    return connection
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(f'https://{host}/json/version') as response:
+                        if response.status == 200:
+                            response_text = await response.text()
+                            if 'Browser' in response_text:
+                                stdout_content = response_text
+                                metadata = json.loads(stdout_content)
+                                
+                                # Update URLs for external access
+                                ws_url = metadata['webSocketDebuggerUrl'].replace(
+                                    'ws://', 'wss://'
+                                ).replace(
+                                    '127.0.0.1:9222', host
+                                )
+                                
+                                http_url = f'https://{host}'
+                                
+                                connection = CDPConnection(
+                                    ws_url=ws_url,
+                                    http_url=http_url,
+                                    port=9222,
+                                    id=str(self.sandbox_service.id)
+                                )
+                                
+                                self.logger.info(f'CDP server is ready (metadata: {metadata})')
+                                return connection
                     
             except Exception as error:
                 self.logger.debug(
@@ -347,8 +376,8 @@ class BrowserService:
                 self._health_check_task = None
             
             # Kill the browser process
-            if hasattr(self.browser_process, 'kill'):
-                await self.browser_process.kill()
+            # if hasattr(self.browser_process, 'kill'):
+            #     await self.browser_process.kill()
             
             self.browser_process = None
             self.cdp_connection = None
@@ -356,8 +385,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,94 @@
+#!/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