grasp-sdk 0.1.6__tar.gz → 0.1.8__tar.gz

{grasp_sdk-0.1.6/grasp_sdk.egg-info → grasp_sdk-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_sdk
-Version: 0.1.6
+Version: 0.1.8
 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.1.6 → grasp_sdk-0.1.8}/grasp_sdk/__init__.py

@@ -24,7 +24,7 @@ from .models import (
     SandboxStatus,
 )
 
-__version__ = "0.1.6"
+__version__ = "0.1.8"
 __author__ = "Grasp Team"
 __email__ = "team@grasp.dev"
 
@@ -76,9 +76,7 @@ class GraspServer:
         
         self.browser_service: Optional[BrowserService] = None
         
-        self.logger.info(
-            f'GraspE2B initialized (templateId: {config["sandbox"]["templateId"]})'
-        )
+        self.logger.info('GraspE2B initialized')
     
     async def __aenter__(self):
         connection = await self.create_browser_task()
@@ -147,7 +145,6 @@ class GraspServer:
             
         # Create base browser config
         browser_config: IBrowserConfig = {
-            'cdpPort': 9222,
             'headless': True,
             'launchTimeout': 30000,
             'args': [
@@ -158,8 +155,6 @@ class GraspServer:
         }
         
         # Apply user config overrides with type safety
-        if 'cdpPort' in config:
-            browser_config['cdpPort'] = config['cdpPort']
         if 'headless' in config:
             browser_config['headless'] = config['headless']
         if 'launchTimeout' in config:
@@ -173,7 +168,7 @@ class GraspServer:
             self.config['sandbox'],
             browser_config
         )
-        await self.browser_service.initialize()
+        await self.browser_service.initialize(browser_type)
 
         # Register server
         _servers[str(self.browser_service.id)] = self
@@ -182,7 +177,7 @@ class GraspServer:
         })
         
         self.logger.info('🌐 Launching Chromium browser with CDP...')
-        cdp_connection = await self.browser_service.launch_browser(browser_type)
+        cdp_connection = await self.browser_service.launch_browser()
         
         self.logger.info('✅ Browser launched successfully!')
         self.logger.debug(

{grasp_sdk-0.1.6 → grasp_sdk-0.1.8}/grasp_sdk/models/__init__.py

@@ -20,7 +20,6 @@ class SandboxStatus(Enum):
 class ISandboxConfig(TypedDict):
     """Sandbox configuration interface."""
     key: str  # Required: Grasp API key
-    templateId: str  # Required: Sandbox template ID
     timeout: int  # Required: Default timeout in milliseconds
     workspace: NotRequired[str]  # Optional: Grasp workspace ID
     debug: NotRequired[bool]  # Optional: Enable debug mode for detailed logging
@@ -28,7 +27,6 @@ class ISandboxConfig(TypedDict):
 
 class IBrowserConfig(TypedDict):
     """Browser service configuration interface."""
-    cdpPort: int  # Required: Port for CDP server (default: 9222)
     args: List[str]  # Required: Chromium launch arguments
     headless: bool  # Required: Headless mode (default: true)
     launchTimeout: int  # Required: Timeout for browser launch (default: 30000ms)

grasp_sdk-0.1.8/grasp_sdk/sandbox/bootstrap-chrome-stable.mjs

@@ -0,0 +1,69 @@
+import { spawn } from 'child_process';
+
+// const asblockPlugin = '/home/user/.config/google-chrome/Default/Extensions/adblock';
+
+const args = [
+  '--no-sandbox',
+  '--disable-setuid-sandbox',
+  '--disable-dev-shm-usage',
+  '--disable-gpu',
+  '--disable-software-rasterizer',
+  '--user-data-dir=/home/user/.browser-context'
+];
+
+args.push(
+  // 避免缓存积累影响性能
+  '--disable-application-cache',
+
+  // 关闭所有硬件加速特性，防止 GPU 相关崩溃
+  '--disable-accelerated-2d-canvas',
+  '--disable-accelerated-video-decode',
+
+  // 禁用后台渲染，减少无关资源消耗
+  '--disable-background-timer-throttling',
+  '--disable-backgrounding-occluded-windows',
+  '--disable-renderer-backgrounding',
+
+  // 避免过度日志影响性能
+  '--disable-logging',
+
+  // 禁用不必要的多媒体解码
+  '--mute-audio',
+
+  // 避免崩溃时弹窗
+  '--no-default-browser-check',
+  '--no-first-run',
+  '--headless=new',
+);
+
+args.push(
+  `--remote-debugging-port=9222`,
+  '--remote-debugging-address=0.0.0.0',
+  'about:blank',
+);
+
+const chromePath = '/usr/bin/google-chrome';
+
+// 启动 Chrome 并启用远程调试
+const chrome = spawn(chromePath, args, {
+  env: { ...process.env, DISPLAY: ':99' }
+});
+
+chrome.stdout.on('data', (data) => {
+  console.log(`stdout: ${data}`);
+});
+
+chrome.stderr.on('data', (data) => {
+  console.error(`stderr: ${data}`);
+});
+
+chrome.on('close', (code) => {
+  console.log(`Chrome process exited with code ${code}`);
+});
+
+console.log('Browser launched and ready...');
+
+// 保持进程不退出，并监听中止信号
+process.stdin.resume();
+process.on('SIGINT', () => process.exit());
+process.on('SIGTERM', () => process.exit());

grasp_sdk-0.1.8/grasp_sdk/sandbox/http-proxy.mjs

@@ -0,0 +1,324 @@
+import httpProxy from 'http-proxy';
+import http from 'http';
+import fs from 'fs';
+
+import { Logtail } from '@logtail/node';
+import * as Sentry from "@sentry/node";
+
+const logtail = new Logtail(process.env.BS_SOURCE_TOKEN, {
+  endpoint: `https://${process.env.BS_INGESTING_HOST}`,
+});
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+
+  // Setting this option to true will send default PII data to Sentry.
+  // For example, automatic IP address collection on events
+  sendDefaultPii: true,
+  _experiments: {
+    enableLogs: true, // 启用日志功能
+  },
+});
+
+const logger = {
+  info: async (message, context) => {
+    Sentry.logger.info(message, context);
+    return logtail.info(message, context);
+  },
+  warn: async (message, context) => {
+    Sentry.logger.warn(message, context);
+    return logtail.warn(message, context);
+  },
+  error: async (message, context) => {
+    Sentry.logger.error(message, context);
+    return logtail.error(message, context);
+  },
+}
+
+function parseWebSocketFrame(buffer) {
+  if (buffer.length < 2) {
+    throw new Error('Incomplete WebSocket frame.');
+  }
+
+  const firstByte = buffer.readUInt8(0);
+  const fin = (firstByte & 0x80) !== 0;
+  const opcode = firstByte & 0x0f;
+
+  // 仅处理文本帧（opcode 为 0x1）
+  if (opcode !== 0x1) {
+    throw new Error(`Unsupported opcode: ${opcode}`);
+  }
+
+  const secondByte = buffer.readUInt8(1);
+  const isMasked = (secondByte & 0x80) !== 0;
+  let payloadLength = secondByte & 0x7f;
+  let offset = 2;
+
+  if (payloadLength === 126) {
+    if (buffer.length < offset + 2) {
+      throw new Error('Incomplete extended payload length.');
+    }
+    payloadLength = buffer.readUInt16BE(offset);
+    offset += 2;
+  } else if (payloadLength === 127) {
+    if (buffer.length < offset + 8) {
+      throw new Error('Incomplete extended payload length.');
+    }
+    // 注意：JavaScript 无法精确表示超过 2^53 的整数
+    const highBits = buffer.readUInt32BE(offset);
+    const lowBits = buffer.readUInt32BE(offset + 4);
+    payloadLength = highBits * 2 ** 32 + lowBits;
+    offset += 8;
+  }
+
+  let maskingKey;
+  if (isMasked) {
+    if (buffer.length < offset + 4) {
+      throw new Error('Incomplete masking key.');
+    }
+    maskingKey = buffer.slice(offset, offset + 4);
+    offset += 4;
+  }
+
+  if (buffer.length < offset + payloadLength) {
+    throw new Error('Incomplete payload data.');
+  }
+
+  const payloadData = buffer.slice(offset, offset + payloadLength);
+
+  if (isMasked) {
+    for (let i = 0; i < payloadLength; i++) {
+      payloadData[i] ^= maskingKey[i % 4];
+    }
+  }
+
+  return payloadData.toString('utf8');
+}
+
+let sandboxId = '';
+const cdpPort = Number(process.env.CDP_PORT);
+const headless = process.env.HEADLESS !== 'false';
+const enableAdblock = process.env.ADBLOCK !== 'false';
+const timeoutMS = process.env.SANBOX_TIMEOUT;
+const workspace = process.env.WORKSPACE;
+const keepAliveMS = Number(process.env.KEEP_ALIVE_MS) || 0;
+const args = [];
+
+try {
+  // 创建代理服务：从 ${this.config.cdpPort! + 1} 转发到 127.0.0.1:${this.config.cdpPort!}
+  const proxy = httpProxy.createProxyServer({
+    target: `http://127.0.0.1:${cdpPort}`,
+    ws: true,               // 支持 WebSocket
+    changeOrigin: true
+  });
+
+  const clients = new Set();
+
+  // 监听 WebSocket 事件
+  proxy.on('open', () => {
+    sandboxId = fs.readFileSync('/home/user/.sandbox_id', 'utf-8');
+    console.log('🔌 CDP WebSocket connection established', sandboxId);
+    const wsId = Date.now();
+    logger.info('CDP WebSocket connection established', { sandboxId, wsId });
+    Sentry.addBreadcrumb({
+      category: 'websocket',
+      message: 'CDP connection established',
+      level: 'info',
+      data: { sandboxId }
+    });
+
+    clients.add(wsId);
+    proxy.once('close', async (req, socket, head) => {
+      console.log('🔒 CDP WebSocket connection closed');
+      await logger.info('CDP WebSocket connection closed', { sandboxId });
+      Sentry.addBreadcrumb({
+        category: 'websocket',
+        message: 'CDP connection closed',
+        level: 'info',
+        data: { sandboxId }
+      });
+      clients.delete(wsId);
+
+      if(clients.size <= 0) {
+        setTimeout(() => {
+          if(clients.size <= 0) {
+            console.log('❌ Force closed...', wsId);
+            process.exit(0);
+          }
+        }, keepAliveMS);
+      }
+    });
+  });
+
+  proxy.on('proxyReqWs', (proxyReq, req, socket, options, head) => {
+    console.log('📡 New CDP WebSocket connection request:', req.url);
+    logger.info('New CDP WebSocket connection request', { url: req.url, sandboxId });
+    Sentry.addBreadcrumb({
+      category: 'websocket',
+      message: 'New CDP connection request',
+      level: 'info',
+      data: { url: req.url, sandboxId }
+    });
+  });
+
+  proxy.on('error', (err, req, res) => {
+    console.error('❌ CDP WebSocket proxy error:', err);
+    logger.error('CDP WebSocket proxy error', { error: err.message, url: req?.url, sandboxId });
+    Sentry.captureException(err, {
+      tags: { type: 'websocket_proxy_error', sandboxId },
+      extra: { url: req?.url }
+    });
+  });
+  
+  const server = http.createServer(async (req, res) => {
+    if (req.url === '/health') {
+      res.end('ok');
+      return;
+    }
+    if (req.url === '/json/version' || req.url === '/json/version/') {
+      try {
+        // 向本地 CDP 发请求，获取原始 JSON
+        const jsonRes = await fetch(`http://127.0.0.1:${cdpPort}/json/version`);
+        const data = await jsonRes.json();
+        // 替换掉本地的 WebSocket 地址为代理暴露地址
+        data.webSocketDebuggerUrl = data.webSocketDebuggerUrl.replace(
+          `ws://127.0.0.1:${cdpPort}`,
+          `wss://${req.headers.host}`
+        );
+        await logger.info('CDP version info requested', { url: req.url, response: data, sandboxId });
+        Sentry.addBreadcrumb({
+          category: 'http',
+          message: 'CDP version info requested',
+          level: 'info',
+          data: { url: req.url, response: data, sandboxId }
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+      } catch(ex) {
+        console.error('Failed to fetch CDP version:', ex.message);
+        await logger.error('Failed to fetch CDP version', { error: ex.message, sandboxId });
+        Sentry.captureException(ex, {
+          tags: { type: 'cdp_version_error', sandboxId }
+        });
+        res.writeHead(500);
+        res.end('Internal Server Error');
+      }
+    } else {
+      proxy.web(req, res, {}, async (err) => {
+        console.error('Proxy error:', err);
+        await logger.error('HTTP proxy error', { error: err.message, url: req.url, sandboxId });
+        Sentry.captureException(err, {
+          tags: { type: 'proxy_error', sandboxId },
+          extra: { url: req.url }
+        });
+        res.writeHead(502);
+        res.end('Bad gateway');
+      });
+    }
+  });
+
+  server.on('upgrade', (req, socket, head) => {
+    // 监听 WebSocket 数据
+    let _buffers = [];
+    socket.on('data', (data) => {
+      let message = '';
+      try {
+        _buffers.push(data);
+        // console.log(`💬 ${_buffers.length}`);
+        message = parseWebSocketFrame(Buffer.concat(_buffers)); // 复制data不能破坏原始数据
+        _buffers.length = 0;
+        if (message.startsWith('{')){  // 只解析 JSON 消息
+          const parsed = JSON.parse(message);
+          console.log('📨 CDP WebSocket message:', parsed);
+          logger.info('CDP WebSocket message received', {
+            data: parsed,
+            sandboxId,
+          });
+          Sentry.addBreadcrumb({
+            category: 'websocket',
+            message: 'CDP message received',
+            level: 'debug',
+            data: { ...parsed, sandboxId }
+          });
+        }
+      } catch (err) {
+        const msg = err.message;
+        if(!msg.includes('Incomplete')) {
+          // 记录解析错误
+          console.warn('⚠️ Failed to parse CDP WebSocket message:', err.message, _buffers.length);
+          _buffers.length = 0;
+          Sentry.captureException(err, {
+            tags: { type: 'websocket_error', sandboxId }
+          });
+          logger.warn('Failed to parse CDP WebSocket message', {
+            error: err.message,
+            data: message,
+            sandboxId,
+          });
+        }
+      }
+    });
+
+    socket.on('error', (err) => {
+      console.error('❌ CDP WebSocket error:', err);
+      logger.error('CDP WebSocket error', { error: err.message, sandboxId });
+      Sentry.captureException(err, {
+        tags: { type: 'websocket_error', sandboxId }
+      });
+    });
+
+    proxy.ws(req, socket, head);
+  });
+
+  server.listen(cdpPort + 1, '0.0.0.0', () => {
+    console.log(`🎯 Proxy server listening on http://0.0.0.0:${cdpPort + 1} → http://127.0.0.1:${cdpPort}`);
+    logger.info('Proxy server started', { 
+      port: cdpPort + 1,
+      target: cdpPort,
+      sandboxId,
+      settings: {
+        type: 'chromium',
+        args,
+        headless,
+        enableAdblock,
+        timeoutMS,
+        workspace,
+        sandboxId
+      },
+    });
+    Sentry.addBreadcrumb({
+      category: 'server',
+      message: 'Proxy server started',
+      level: 'info',
+      data: { 
+        port: cdpPort + 1,
+        target: cdpPort,
+        sandboxId,
+        settings: {
+          type: 'chromium',
+          args,
+          headless,
+          enableAdblock,
+          timeoutMS,
+          workspace,
+          sandboxId
+        },
+      }
+    });
+  });
+} catch (ex) {
+  console.error('Failed to launch Chromium:', ex);
+  logger.error('Failed to launch Chrome', {
+    error: ex.message,
+    args,
+    headless,
+    cdpPort,
+    enableAdblock,
+    sandboxId,
+  });
+  Sentry.captureException(ex, {
+    tags: { type: 'launch_error', sandboxId },
+    extra: { args, headless, cdpPort, enableAdblock }
+  });
+  process.exit(1);
+}

{grasp_sdk-0.1.6 → grasp_sdk-0.1.8}/grasp_sdk/services/browser.py

@@ -63,7 +63,6 @@ class BrowserService:
         
         # Set default browser config
         default_config: IBrowserConfig = {
-            'cdpPort': 9222,
             'headless': True,
             'launchTimeout': 30000,
             'args': [],
@@ -92,19 +91,34 @@ class BrowserService:
             })
             return default_logger.child('BrowserService')
 
-    async def initialize(self) -> None:
+    async def initialize(self, browser_type: str) -> None:
         """Initialize the Grasp sandbox.
         
         Returns:
             Promise that resolves when sandbox is ready
         """
         self.logger.info('Initializing Browser service')
-        await self.sandbox_service.create_sandbox()
+        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,
+            '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',
+            **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)
         self.logger.info('Grasp sandbox initialized successfully')
     
     async def launch_browser(
         self,
-        browser_type: str = 'chromium'
     ) -> CDPConnection:
         """Launch Chromium browser with CDP server.
         
@@ -122,43 +136,18 @@ class BrowserService:
         
         try:
             self.logger.info(
-                f'Launching Chromium browser with CDP (port: {self.config["cdpPort"]}, headless: {self.config["headless"]})'
-            )
-            
-            # Check if adblock is enabled and adjust browser type
-            if (
-                self.config['envs'].get('ADBLOCK') == 'true' and 
-                browser_type == 'chromium'
-            ):
-                self.logger.warn(
-                    '⚠️ Adblock is enabled. Should use chrome-stable instead.'
-                )
-                browser_type = 'chrome-stable'
+                f'Launching Chromium browser with CDP (port: 9222, headless: {self.config["headless"]})')
             
             # Read the Playwright script
-            script_path = Path(__file__).parent.parent / 'sandbox' / f'{browser_type}.mjs'
-            
-            try:
-                with open(script_path, 'r', encoding='utf-8') as f:
-                    playwright_script = f.read()
-            except FileNotFoundError:
-                raise RuntimeError(f'Browser script not found: {script_path}')
+            # script_path = Path(__file__).parent.parent / 'sandbox' / 'http-proxy.mjs'
             
-            # Prepare environment variables
-            envs = {
-                'CDP_PORT': str(self.config['cdpPort']),
-                '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,
-                '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',
-                **self.config['envs']
-            }
+            # try:
+            #     with open(script_path, 'r', encoding='utf-8') as f:
+            #         playwright_script = f.read()
+            # except FileNotFoundError:
+            #     raise RuntimeError(f'Browser script not found: {script_path}')
+
+            playwright_script = '/home/user/http-proxy.mjs'
             
             # Prepare script options
             from ..models import IScriptOptions
@@ -167,7 +156,6 @@ class BrowserService:
                 'background': True,
                 'nohup': not self.sandbox_service.is_debug,
                 'timeoutMs': 0,
-                'envs': envs,
                 'preCommand': '' if self.config['headless'] else 'xvfb-run -a -s "-screen 0 1280x1024x24" '
             }
             
@@ -187,7 +175,7 @@ class BrowserService:
             self.cdp_connection = result
             
             self.logger.info(
-                f'Chromium browser launched successfully (cdpPort: {self.config["cdpPort"]}, wsUrl: {self.cdp_connection.ws_url})'
+                f'Chromium browser launched successfully (cdpPort: 9222, wsUrl: {self.cdp_connection.ws_url})'
             )
             
             # Start health check if not in debug mode
@@ -238,7 +226,7 @@ class BrowserService:
         Raises:
             RuntimeError: If CDP server fails to become ready within timeout
         """
-        delay_ms = 200
+        delay_ms = 100
         max_attempts = self.config['launchTimeout'] // delay_ms
         
         for attempt in range(1, max_attempts + 1):
@@ -246,6 +234,10 @@ class BrowserService:
                 self.logger.debug(
                     f'Checking CDP availability (attempt {attempt}/{max_attempts})'
                 )
+
+                host = self.sandbox_service.get_sandbox_host(
+                    9223
+                )
                 
                 # Check if CDP endpoint is responding
                 options: ICommandOptions = {
@@ -253,7 +245,7 @@ class BrowserService:
                     'inBackground': False
                 }
                 result = await self.sandbox_service.run_command(
-                    f'curl -s http://localhost:{self.config["cdpPort"]}/json/version',
+                    f'curl -s https://{host}/json/version',
                     options,
                     True,
                 )
@@ -264,15 +256,12 @@ class BrowserService:
                 ):
                     stdout_content = getattr(result, 'stdout', '')
                     metadata = json.loads(stdout_content)
-                    host = self.sandbox_service.get_sandbox_host(
-                        self.config['cdpPort'] + 1
-                    )
                     
                     # Update URLs for external access
                     ws_url = metadata['webSocketDebuggerUrl'].replace(
                         'ws://', 'wss://'
                     ).replace(
-                        f'localhost:{self.config["cdpPort"]}', host
+                        f'localhost:9222', host
                     )
                     
                     http_url = f'https://{host}'
@@ -280,7 +269,7 @@ class BrowserService:
                     connection = CDPConnection(
                         ws_url=ws_url,
                         http_url=http_url,
-                        port=self.config['cdpPort']
+                        port=9222
                     )
                     
                     self.logger.info(f'CDP server is ready (metadata: {metadata})')

{grasp_sdk-0.1.6 → grasp_sdk-0.1.8}/grasp_sdk/services/sandbox.py

@@ -123,7 +123,7 @@ class SandboxService:
         """Get timeout value."""
         return self.config['timeout']
     
-    async def create_sandbox(self) -> None:
+    async def create_sandbox(self, template_id: str, envs: Optional[Dict[str, str]] = None) -> None:
         """
         Creates and starts a new sandbox.
         
@@ -143,13 +143,14 @@ class SandboxService:
             
             # Create sandbox
             self.logger.info('Creating Grasp sandbox', {
-                'templateId': self.config['templateId'],
+                'templateId': template_id,
             })
             # Use Sandbox constructor directly (e2b SDK 1.5.3+)
             self.sandbox = await AsyncSandbox.create(
-                template=self.config['templateId'],
+                template=template_id,    
                 api_key=api_key,
-                timeout=self.config['timeout'] // 1000  # Convert ms to seconds
+                timeout=self.config['timeout'] // 1000,  # Convert ms to seconds
+                envs=envs,
             )
 
             self.status = SandboxStatus.RUNNING
@@ -322,7 +323,7 @@ class SandboxService:
         Runs JavaScript code in the sandbox.
         
         Args:
-            code: JavaScript code to execute
+            code: JavaScript code to execute, or file path starting with '/home/user/'
             options: Script execution options
             
         Returns:
@@ -331,6 +332,10 @@ class SandboxService:
             
         Raises:
             RuntimeError: If sandbox is not running or script execution fails
+            
+        Note:
+            If code starts with '/home/user/', it will be treated as a file path.
+            Otherwise, it will be treated as JavaScript code and written to a temporary file.
         """
         if not self.sandbox or self.status != SandboxStatus.RUNNING:
             raise RuntimeError('Sandbox is not running. Call create_sandbox() first.')
@@ -341,9 +346,14 @@ class SandboxService:
         try:
             # Generate temporary file name in working directory
             timestamp = int(time.time() * 1000)
-            extension = 'mjs' if options['type'] == 'esm' else 'js'
-            working_dir = options.get('cwd', self.DEFAULT_WORKING_DIRECTORY)
-            script_path = f'{working_dir}/script_{timestamp}.{extension}'
+            script_path = code
+            
+            if not code.startswith('/home/user/'):
+                extension = 'mjs' if options['type'] == 'esm' else 'js'
+                working_dir = options.get('cwd', self.DEFAULT_WORKING_DIRECTORY)
+                script_path = f'{working_dir}/script_{timestamp}.{extension}'
+                # Write code to temporary file
+                await self.sandbox.files.write(script_path, code)
             
             self.logger.debug('Running JavaScript code in sandbox', {
                 'type': options['type'],
@@ -351,9 +361,6 @@ class SandboxService:
                 'codeLength': len(code),
             })
             
-            # Write code to temporary file
-            await self.sandbox.files.write(script_path, code)
-            
             # Choose execution command based on type
             pre_command = options.get('preCommand', '')
             command = f'{pre_command}node {script_path}'
@@ -374,16 +381,6 @@ class SandboxService:
             # Execute the script
             result = await self.run_command(command, cmd_options)
             
-            # Cleanup temporary file (if not background execution)
-            if not options.get('background', False):
-                try:
-                    await self.run_command(f'rm -f {script_path}')
-                except Exception as cleanup_error:
-                    self.logger.warn('Failed to cleanup script file', {
-                        'scriptPath': script_path,
-                        'error': cleanup_error,
-                    })
-            
             return result
         
         except Exception as error:

{grasp_sdk-0.1.6 → grasp_sdk-0.1.8}/grasp_sdk/utils/config.py

@@ -23,7 +23,6 @@ def get_config() -> Dict[str, Any]:
     return {
         'sandbox': {
             'key': os.getenv('GRASP_KEY', ''),
-            'templateId': 'playwright-pnpm-template',
             'timeout': int(os.getenv('GRASP_SERVICE_TIMEOUT', '900000')),
             'debug': os.getenv('GRASP_DEBUG', 'false').lower() == 'true',
         },
@@ -44,7 +43,6 @@ def get_sandbox_config() -> ISandboxConfig:
     config = get_config()
     sandbox_config = ISandboxConfig(
         key=config['sandbox']['key'],
-        templateId=config['sandbox']['templateId'],
         timeout=config['sandbox']['timeout'],
         debug=config['sandbox'].get('debug', False),
     )
@@ -64,7 +62,6 @@ def get_browser_config() -> IBrowserConfig:
         IBrowserConfig: Browser configuration object.
     """
     return IBrowserConfig(
-        cdpPort=int(os.getenv('GRASP_CDP_PORT', '9222')),
         args=[
             '--no-sandbox',
             '--disable-setuid-sandbox',
@@ -102,7 +99,6 @@ ENV_VARS = {
     'GRASP_DEBUG': 'GRASP_DEBUG',
     'GRASP_LOG_LEVEL': 'GRASP_LOG_LEVEL',
     'GRASP_LOG_FILE': 'GRASP_LOG_FILE',
-    'GRASP_CDP_PORT': 'GRASP_CDP_PORT',
     'GRASP_HEADLESS': 'GRASP_HEADLESS',
     'GRASP_LAUNCH_TIMEOUT': 'GRASP_LAUNCH_TIMEOUT',
 }

{grasp_sdk-0.1.6 → grasp_sdk-0.1.8/grasp_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_sdk
-Version: 0.1.6
+Version: 0.1.8
 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.1.6 → grasp_sdk-0.1.8}/grasp_sdk.egg-info/SOURCES.txt

@@ -30,8 +30,10 @@ grasp_sdk.egg-info/not-zip-safe
 grasp_sdk.egg-info/requires.txt
 grasp_sdk.egg-info/top_level.txt
 grasp_sdk/models/__init__.py
+grasp_sdk/sandbox/bootstrap-chrome-stable.mjs
 grasp_sdk/sandbox/chrome-stable.mjs
 grasp_sdk/sandbox/chromium.mjs
+grasp_sdk/sandbox/http-proxy.mjs
 grasp_sdk/services/__init__.py
 grasp_sdk/services/browser.py
 grasp_sdk/services/sandbox.py

{grasp_sdk-0.1.6 → grasp_sdk-0.1.8}/pyproject.toml

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