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

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

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

@@ -24,7 +24,7 @@ from .models import (
     SandboxStatus,
 )
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 __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:

{grasp_sdk-0.1.6 → grasp_sdk-0.1.7}/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.7/grasp_sdk/sandbox/http-proxy.mjs

@@ -0,0 +1,322 @@
+import httpProxy from 'http-proxy';
+import http from 'http';
+
+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');
+}
+
+const sandboxId = process.env.SANDBOX_ID;
+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', () => {
+    console.log('🔌 CDP WebSocket connection established');
+    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: process.env.SANDBOX_ID,
+          });
+          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: process.env.SANDBOX_ID
+          });
+        }
+      }
+    });
+
+    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.7}/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': [],
@@ -99,7 +98,7 @@ class BrowserService:
             Promise that resolves when sandbox is ready
         """
         self.logger.info('Initializing Browser service')
-        await self.sandbox_service.create_sandbox()
+        await self.sandbox_service.create_sandbox('grasp-run-template')
         self.logger.info('Grasp sandbox initialized successfully')
     
     async def launch_browser(
@@ -122,8 +121,8 @@ class BrowserService:
         
         try:
             self.logger.info(
-                f'Launching Chromium browser with CDP (port: {self.config["cdpPort"]}, headless: {self.config["headless"]})'
-            )
+                f'Launching Chromium browser with CDP (port: 9222, headless: {self.config["headless"]})')
+            
             
             # Check if adblock is enabled and adjust browser type
             if (
@@ -136,7 +135,7 @@ class BrowserService:
                 browser_type = 'chrome-stable'
             
             # Read the Playwright script
-            script_path = Path(__file__).parent.parent / 'sandbox' / f'{browser_type}.mjs'
+            script_path = Path(__file__).parent.parent / 'sandbox' / 'http-proxy.mjs'
             
             try:
                 with open(script_path, 'r', encoding='utf-8') as f:
@@ -146,7 +145,7 @@ class BrowserService:
             
             # Prepare environment variables
             envs = {
-                'CDP_PORT': str(self.config['cdpPort']),
+                'CDP_PORT': '9222',
                 'BROWSER_ARGS': json.dumps(self.config['args']),
                 'LAUNCH_TIMEOUT': str(self.config['launchTimeout']),
                 'SANDBOX_TIMEOUT': str(self.sandbox_service.timeout),
@@ -187,7 +186,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 +237,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 +245,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 +256,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 +267,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 +280,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.7}/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) -> None:
         """
         Creates and starts a new sandbox.
         
@@ -143,11 +143,11 @@ 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
             )

{grasp_sdk-0.1.6 → grasp_sdk-0.1.7}/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.7/grasp_sdk.egg-info}/PKG-INFO

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

@@ -32,6 +32,7 @@ grasp_sdk.egg-info/top_level.txt
 grasp_sdk/models/__init__.py
 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.7}/pyproject.toml

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