| Name | screenenv JSON |
| Version |
0.1.1
JSON |
| download |
| home_page | None |
| Summary | A powerful Python library for creating and managing isolated desktop environments using Docker containers |
| upload_time | 2025-07-09 21:45:28 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.10 |
| license | MIT |
| keywords |
automation
desktop
docker
gui
playwright
sandbox
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# ScreenEnv
A powerful Python library for creating and managing isolated desktop environments using Docker containers. ScreenEnv provides a sandboxed Ubuntu desktop environment with XFCE4 that you can programmatically control for GUI automation, testing, and development.
## Features
- 🖥️ **Isolated Desktop Environment**: Full Ubuntu desktop with XFCE4 running in Docker
- 🎮 **GUI Automation**: Complete mouse and keyboard control
- 🌐 **Web Automation**: Built-in browser automation with Playwright
- 📹 **Screen Recording**: Capture video recordings of all actions
- 📸 **Screenshot Capabilities**: Desktop and browser screenshots
- 🖱️ **Mouse Control**: Click, drag, scroll, and mouse movement
- ⌨️ **Keyboard Input**: Text typing and key combinations
- 🪟 **Window Management**: Launch, activate, and close applications
- 📁 **File Operations**: Upload, download, and file management
- 🐚 **Terminal Access**: Execute commands and capture output
- 🤖 **MCP Server Support**: Model Context Protocol integration for AI/LLM automation
- 🐳 **Docker Ready**: Pre-built Docker image with all dependencies
## Quick Start
### Installation
1. **Clone the repository**:
```bash
git clone <repository-url>
cd screenenv
```
2. **Install the package** (choose one):
**latest release:**
```bash
pip install screenenv
# or
uv pip install screenenv
```
**from source:**
```bash
pip install .
# or
uv sync
```
### Basic Usage
```python
from screenenv import Sandbox
# Create a sandbox environment
sandbox = Sandbox()
try:
# Launch a terminal
sandbox.launch("xfce4-terminal")
# Type some text
sandbox.write("echo 'Hello from ScreenEnv!'")
sandbox.press("Enter")
# Take a screenshot
screenshot = sandbox.screenshot()
with open("screenshot.png", "wb") as f:
f.write(screenshot)
finally:
# Clean up
sandbox.close()
```
> For usage, see the source code in `examples/sandbox_demo.py`
## MCP Server Support
ScreenEnv includes full support for the Model Context Protocol (MCP), enabling seamless integration with AI/LLM systems for desktop automation.
### What is MCP?
The Model Context Protocol (MCP) is a standard for AI assistants to interact with external tools and data sources. ScreenEnv's MCP server provides desktop automation capabilities that can be used by any MCP-compatible AI system.
### MCP Server Features
- **30+ Automation Tools**: Complete desktop control via MCP
- **Streamable HTTP Transport**: Efficient communication protocol
### Starting the MCP Server
```python
from screenenv import MCPRemoteServer
# Start MCP server
server = MCPRemoteServer()
print(f"MCP Server URL: {server.server_url}")
print(f"Server Configuration: {server.mcp_server_json}")
```
### MCP Client Usage
```python
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from screenenv import MCPRemoteServer
async def mcp_automation():
# Start MCP server
server = MCPRemoteServer(headless=False)
try:
# Connect to MCP server
async with streamablehttp_client(server.server_url) as (
read_stream, write_stream, _
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
# Launch terminal
await session.call_tool("launch", {
"application": "xfce4-terminal",
"wait_for_window": True
})
# Type commands
await session.call_tool("write", {"text": "echo 'Hello MCP!'"})
await session.call_tool("press", {"key": ["Enter"]})
# Take screenshot
response = await session.call_tool("screenshot", {})
screenshot_base64 = response.content[0].data
screenshot_bytes = base64.b64decode(screenshot_base64)
image = Image.open(io.BytesIO(screenshot_bytes))
image.save("screenshot.png")
...
print("MCP automation completed!")
finally:
server.close()
# Run the automation
asyncio.run(mcp_automation())
```
### Available MCP Tools
#### System Operations
- `execute_command` - Execute shell commands
- `get_platform` - Get system platform information
- `get_screen_size` - Get screen dimensions
- `get_desktop_path` - Get desktop directory path
- `get_directory_tree` - List directory contents
- `get_file` - Get file contents
- `download_file` - Download file from URL
- `start_recording` - Start screen recording
- `end_recording` - End screen recording
#### Application Management
- `wait` - Wait for specified milliseconds
- `open` - Open file or URL
- `launch` - Launch application
- `get_current_window_id` - Get current window ID
- `get_application_windows` - Get windows for application
- `get_window_name` - Get window name/title
- `get_window_size` - Get window size
- `activate_window` - Activate window
- `close_window` - Close window
- `get_terminal_output` - Get terminal output
#### GUI Automation
- `screenshot` - Take screenshot
- `left_click` - Left click at coordinates
- `double_click` - Double click at coordinates
- `right_click` - Right click at coordinates
- `middle_click` - Middle click at coordinates
- `scroll` - Scroll mouse wheel
- `move_mouse` - Move mouse to coordinates
- `mouse_press` - Press mouse button
- `mouse_release` - Release mouse button
- `get_cursor_position` - Get cursor position
- `write` - Type text
- `press` - Press keys
- `drag` - Drag mouse from one position to another
### MCP Server Configuration
```python
# Advanced MCP server configuration
server = MCPRemoteServer(
os_type="Ubuntu",
provider_type="docker",
headless=True,
resolution=(1920, 1080),
disk_size="32G",
ram_size="4G",
cpu_cores="4",
session_password="your_password",
stream_server=True,
dpi=96,
timeout=1000
)
```
## Sandbox Instantiation
### Basic Configuration
```python
from screenenv import Sandbox
# Minimal configuration
sandbox = Sandbox()
# With custom settings
sandbox = Sandbox(
os_type="Ubuntu", # Currently only Ubuntu is supported
provider_type="docker", # Currently only Docker is supported
headless=True, # Run without VNC viewer
screen_size="1920x1080", # Desktop resolution
volumes=[], # Docker volumes to mount
auto_ssl=False # Enable SSL for VNC (experimental)
)
```
## Core Features
### Mouse Control
```python
# Click operations
sandbox.left_click(x=100, y=200)
sandbox.right_click(x=300, y=400)
sandbox.double_click(x=500, y=600)
# Mouse movement
sandbox.move_mouse(x=800, y=900)
# Drag and drop
sandbox.drag(fr=(100, 100), to=(200, 200))
# Scrolling
sandbox.scroll(direction="down", amount=3)
sandbox.mouse_release(button="left")
sandbox.mouse_press(button="left")
sandbox.mouse_release(button="left")
```
### Keyboard Input
```python
# Type text
sandbox.write("Hello, World!", delay_in_ms=50)
# Key combinations
sandbox.press(["Ctrl", "C"]) # Copy
sandbox.press(["Ctrl", "V"]) # Paste
sandbox.press(["Alt", "Tab"]) # Switch windows
sandbox.press("Enter") # Single key
```
### Application Management
```python
# Launch applications
sandbox.launch("xfce4-terminal")
sandbox.launch("libreoffice --writer")
sandbox.open("https://www.google.com")
# Window management
windows = sandbox.get_application_windows("xfce4-terminal")
window_id = windows[0]
sandbox.activate_window(window_id)
window_id = sandbox.get_current_window_id() # get the current activate window id.
sandbox.window_size(window_id)
sandbox.get_window_title(window_id)
sandbox.close_window(window_id)
```
### File Operations
```python
# Upload files to sandbox
sandbox.upload_file_to_remote("local_file.txt", "/home/user/remote_file.txt")
# Download files from sandbox
sandbox.download_file_from_remote("/home/user/remote_file.txt", "local_file.txt")
# Download from URL
sandbox.download_url_file_to_remote("https://example.com/file.txt", "/home/user/file.txt")
```
### Screenshots and Recording
```python
# Start recording
sandbox.start_recording()
# Take screenshots
desktop_screenshot = sandbox.desktop_screenshot()
# Stop recording and save it locally to a file 'demo.mp4'
sandbox.end_recording("demo.mp4")
```
### Terminal Operations
```python
# Execute commands
response = sandbox.execute_command("ls -la")
print(response.output)
# Python commands
response = sandbox.execute_python_command("print('Hello')", ["os"])
print(response.output)
# Get terminal output
output = sandbox.get_terminal_output() # Only if a desktop terminal application is running. To get command output, use execute_command() instead.
```
## Examples
### Complete GUI Automation Demo
```python
from screenenv import Sandbox
import time
def demo_automation():
sandbox = Sandbox(headless=False)
try:
# Launch terminal
sandbox.launch("xfce4-terminal")
time.sleep(2)
# Type commands
sandbox.write("echo 'Starting automation demo'")
sandbox.press("Enter")
# Open web browser
sandbox.open("https://www.python.org")
time.sleep(3)
# Take screenshot
screenshot = sandbox.screenshot()
with open("demo_screenshot.png", "wb") as f:
f.write(screenshot)
finally:
sandbox.close()
if __name__ == "__main__":
demo_automation()
```
### Web Automation with Playwright
```python
from screenenv import Sandbox
def web_automation():
sandbox = Sandbox(headless=True)
try:
# Open website
sandbox.open("https://www.example.com")
# Take browser screenshot
screenshot = sandbox.playwright_screenshot(full_page=True)
with open("web_screenshot.png", "wb") as f:
f.write(screenshot)
playwright_browser = sandbox.playwright_browser()
finally:
sandbox.close()
```
### Benefits
- **Single Entry Point**: All services accessible through one port
- **Clean URLs**: Organized by service type (`/api`, `/novnc`, `/browser`, `/mcp`)
- **Load Balancing Ready**: Easy to add multiple backend instances
## MCP Server Demo
```bash
python -m examples.mcp_server_demo # or sudo -E python -m examples.mcp_server_demo if not in docker group
```
## Sandbox Demo
```bash
python -m examples.sandbox_demo # or sudo -E python -m examples.sandbox_demo if not in docker group
```
## Computer Agent Demo
```bash
cd examples/computer_agent
python app.py # or sudo -E python app.py if not in docker group
```
## System Requirements
- **Docker**: Must be installed and running
- **Python**: 3.10 or higher
- **Playwright**: For web automation features
- **Memory**: At least 4GB RAM recommended
## Docker Image
The sandbox uses a custom Ubuntu 22.04 Docker image with:
- XFCE4 desktop environment
- VNC server for remote access
- Google Chrome/Chromium browser
- LibreOffice suite
- Python development tools
- MCP server support
- Nginx reverse proxy
### Docker Usage
```bash
docker run -p7860:7860 amhma/ubuntu-desktop
```
variables:
- `-p7860:7860` - port forwarding (must match the ENDPOINT_PORT variable, default is 7860)
- `-e DISPLAY=:1` - X11 display (default: :1)
- `-e SCREEN_SIZE=1920x1080x24` - screen resolution and color depth (default: 1920x1080x24)
- `-e SERVER_TYPE=mcp` - server type (default: mcp) values: mcp, fastapi
- `-e DPI=96` - display DPI (default: 96)
- `-e NOVNC_SERVER_ENABLED=true` - enable noVNC server (default: true)
- `-e SESSION_PASSWORD=""` - session password (default: empty)
- `-e ENDPOINT_PORT=7860` - endpoint port (default: 7860)
Raw data
{
"_id": null,
"home_page": null,
"name": "screenenv",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "automation, desktop, docker, gui, playwright, sandbox",
"author": null,
"author_email": "Amir Mahla <amir.mahla@icloud.com>",
"download_url": "https://files.pythonhosted.org/packages/80/e8/ff2c843ef483d760e6f47b1a6c8dca978f36f23547f1258a81e37ef3aea7/screenenv-0.1.1.tar.gz",
"platform": null,
"description": "# ScreenEnv\n\nA powerful Python library for creating and managing isolated desktop environments using Docker containers. ScreenEnv provides a sandboxed Ubuntu desktop environment with XFCE4 that you can programmatically control for GUI automation, testing, and development.\n\n## Features\n\n- \ud83d\udda5\ufe0f **Isolated Desktop Environment**: Full Ubuntu desktop with XFCE4 running in Docker\n- \ud83c\udfae **GUI Automation**: Complete mouse and keyboard control\n- \ud83c\udf10 **Web Automation**: Built-in browser automation with Playwright\n- \ud83d\udcf9 **Screen Recording**: Capture video recordings of all actions\n- \ud83d\udcf8 **Screenshot Capabilities**: Desktop and browser screenshots\n- \ud83d\uddb1\ufe0f **Mouse Control**: Click, drag, scroll, and mouse movement\n- \u2328\ufe0f **Keyboard Input**: Text typing and key combinations\n- \ud83e\ude9f **Window Management**: Launch, activate, and close applications\n- \ud83d\udcc1 **File Operations**: Upload, download, and file management\n- \ud83d\udc1a **Terminal Access**: Execute commands and capture output\n- \ud83e\udd16 **MCP Server Support**: Model Context Protocol integration for AI/LLM automation\n- \ud83d\udc33 **Docker Ready**: Pre-built Docker image with all dependencies\n\n## Quick Start\n\n### Installation\n\n1. **Clone the repository**:\n ```bash\n git clone <repository-url>\n cd screenenv\n ```\n\n2. **Install the package** (choose one):\n\n **latest release:**\n ```bash\n pip install screenenv\n # or\n uv pip install screenenv\n ```\n\n **from source:**\n ```bash\n pip install .\n # or\n uv sync\n ```\n\n\n### Basic Usage\n\n```python\nfrom screenenv import Sandbox\n\n# Create a sandbox environment\nsandbox = Sandbox()\n\ntry:\n # Launch a terminal\n sandbox.launch(\"xfce4-terminal\")\n\n # Type some text\n sandbox.write(\"echo 'Hello from ScreenEnv!'\")\n sandbox.press(\"Enter\")\n\n # Take a screenshot\n screenshot = sandbox.screenshot()\n with open(\"screenshot.png\", \"wb\") as f:\n f.write(screenshot)\n\nfinally:\n # Clean up\n sandbox.close()\n```\n\n> For usage, see the source code in `examples/sandbox_demo.py`\n\n## MCP Server Support\n\nScreenEnv includes full support for the Model Context Protocol (MCP), enabling seamless integration with AI/LLM systems for desktop automation.\n\n### What is MCP?\n\nThe Model Context Protocol (MCP) is a standard for AI assistants to interact with external tools and data sources. ScreenEnv's MCP server provides desktop automation capabilities that can be used by any MCP-compatible AI system.\n\n### MCP Server Features\n\n- **30+ Automation Tools**: Complete desktop control via MCP\n- **Streamable HTTP Transport**: Efficient communication protocol\n\n### Starting the MCP Server\n\n```python\nfrom screenenv import MCPRemoteServer\n\n# Start MCP server\nserver = MCPRemoteServer()\n\nprint(f\"MCP Server URL: {server.server_url}\")\nprint(f\"Server Configuration: {server.mcp_server_json}\")\n```\n\n### MCP Client Usage\n\n```python\nimport asyncio\nfrom mcp import ClientSession\nfrom mcp.client.streamable_http import streamablehttp_client\nfrom screenenv import MCPRemoteServer\n\nasync def mcp_automation():\n # Start MCP server\n server = MCPRemoteServer(headless=False)\n\n try:\n # Connect to MCP server\n async with streamablehttp_client(server.server_url) as (\n read_stream, write_stream, _\n ):\n async with ClientSession(read_stream, write_stream) as session:\n await session.initialize()\n\n # Launch terminal\n await session.call_tool(\"launch\", {\n \"application\": \"xfce4-terminal\",\n \"wait_for_window\": True\n })\n\n # Type commands\n await session.call_tool(\"write\", {\"text\": \"echo 'Hello MCP!'\"})\n await session.call_tool(\"press\", {\"key\": [\"Enter\"]})\n\n # Take screenshot\n response = await session.call_tool(\"screenshot\", {})\n screenshot_base64 = response.content[0].data\n\n screenshot_bytes = base64.b64decode(screenshot_base64)\n image = Image.open(io.BytesIO(screenshot_bytes))\n image.save(\"screenshot.png\")\n ...\n\n print(\"MCP automation completed!\")\n\n finally:\n server.close()\n\n# Run the automation\nasyncio.run(mcp_automation())\n```\n\n### Available MCP Tools\n\n#### System Operations\n- `execute_command` - Execute shell commands\n- `get_platform` - Get system platform information\n- `get_screen_size` - Get screen dimensions\n- `get_desktop_path` - Get desktop directory path\n- `get_directory_tree` - List directory contents\n- `get_file` - Get file contents\n- `download_file` - Download file from URL\n- `start_recording` - Start screen recording\n- `end_recording` - End screen recording\n\n#### Application Management\n- `wait` - Wait for specified milliseconds\n- `open` - Open file or URL\n- `launch` - Launch application\n- `get_current_window_id` - Get current window ID\n- `get_application_windows` - Get windows for application\n- `get_window_name` - Get window name/title\n- `get_window_size` - Get window size\n- `activate_window` - Activate window\n- `close_window` - Close window\n- `get_terminal_output` - Get terminal output\n\n#### GUI Automation\n- `screenshot` - Take screenshot\n- `left_click` - Left click at coordinates\n- `double_click` - Double click at coordinates\n- `right_click` - Right click at coordinates\n- `middle_click` - Middle click at coordinates\n- `scroll` - Scroll mouse wheel\n- `move_mouse` - Move mouse to coordinates\n- `mouse_press` - Press mouse button\n- `mouse_release` - Release mouse button\n- `get_cursor_position` - Get cursor position\n- `write` - Type text\n- `press` - Press keys\n- `drag` - Drag mouse from one position to another\n\n### MCP Server Configuration\n\n```python\n# Advanced MCP server configuration\nserver = MCPRemoteServer(\n os_type=\"Ubuntu\",\n provider_type=\"docker\",\n headless=True,\n resolution=(1920, 1080),\n disk_size=\"32G\",\n ram_size=\"4G\",\n cpu_cores=\"4\",\n session_password=\"your_password\",\n stream_server=True,\n dpi=96,\n timeout=1000\n)\n```\n\n## Sandbox Instantiation\n\n### Basic Configuration\n\n```python\nfrom screenenv import Sandbox\n\n# Minimal configuration\nsandbox = Sandbox()\n\n# With custom settings\nsandbox = Sandbox(\n os_type=\"Ubuntu\", # Currently only Ubuntu is supported\n provider_type=\"docker\", # Currently only Docker is supported\n headless=True, # Run without VNC viewer\n screen_size=\"1920x1080\", # Desktop resolution\n volumes=[], # Docker volumes to mount\n auto_ssl=False # Enable SSL for VNC (experimental)\n)\n```\n\n## Core Features\n\n### Mouse Control\n\n```python\n# Click operations\nsandbox.left_click(x=100, y=200)\nsandbox.right_click(x=300, y=400)\nsandbox.double_click(x=500, y=600)\n\n# Mouse movement\nsandbox.move_mouse(x=800, y=900)\n\n# Drag and drop\nsandbox.drag(fr=(100, 100), to=(200, 200))\n\n# Scrolling\nsandbox.scroll(direction=\"down\", amount=3)\n\nsandbox.mouse_release(button=\"left\")\n\nsandbox.mouse_press(button=\"left\")\nsandbox.mouse_release(button=\"left\")\n```\n\n### Keyboard Input\n\n```python\n# Type text\nsandbox.write(\"Hello, World!\", delay_in_ms=50)\n\n# Key combinations\nsandbox.press([\"Ctrl\", \"C\"]) # Copy\nsandbox.press([\"Ctrl\", \"V\"]) # Paste\nsandbox.press([\"Alt\", \"Tab\"]) # Switch windows\nsandbox.press(\"Enter\") # Single key\n```\n\n### Application Management\n\n```python\n# Launch applications\nsandbox.launch(\"xfce4-terminal\")\nsandbox.launch(\"libreoffice --writer\")\nsandbox.open(\"https://www.google.com\")\n\n# Window management\nwindows = sandbox.get_application_windows(\"xfce4-terminal\")\nwindow_id = windows[0]\nsandbox.activate_window(window_id)\n\nwindow_id = sandbox.get_current_window_id() # get the current activate window id.\nsandbox.window_size(window_id)\nsandbox.get_window_title(window_id)\nsandbox.close_window(window_id)\n```\n\n### File Operations\n\n```python\n# Upload files to sandbox\nsandbox.upload_file_to_remote(\"local_file.txt\", \"/home/user/remote_file.txt\")\n\n# Download files from sandbox\nsandbox.download_file_from_remote(\"/home/user/remote_file.txt\", \"local_file.txt\")\n\n# Download from URL\nsandbox.download_url_file_to_remote(\"https://example.com/file.txt\", \"/home/user/file.txt\")\n```\n\n### Screenshots and Recording\n\n```python\n# Start recording\nsandbox.start_recording()\n\n# Take screenshots\ndesktop_screenshot = sandbox.desktop_screenshot()\n\n# Stop recording and save it locally to a file 'demo.mp4'\nsandbox.end_recording(\"demo.mp4\")\n```\n\n### Terminal Operations\n\n```python\n# Execute commands\nresponse = sandbox.execute_command(\"ls -la\")\nprint(response.output)\n\n# Python commands\nresponse = sandbox.execute_python_command(\"print('Hello')\", [\"os\"])\nprint(response.output)\n\n# Get terminal output\noutput = sandbox.get_terminal_output() # Only if a desktop terminal application is running. To get command output, use execute_command() instead.\n```\n\n## Examples\n\n### Complete GUI Automation Demo\n\n```python\nfrom screenenv import Sandbox\nimport time\n\ndef demo_automation():\n sandbox = Sandbox(headless=False)\n\n try:\n # Launch terminal\n sandbox.launch(\"xfce4-terminal\")\n time.sleep(2)\n\n # Type commands\n sandbox.write(\"echo 'Starting automation demo'\")\n sandbox.press(\"Enter\")\n\n # Open web browser\n sandbox.open(\"https://www.python.org\")\n time.sleep(3)\n\n # Take screenshot\n screenshot = sandbox.screenshot()\n with open(\"demo_screenshot.png\", \"wb\") as f:\n f.write(screenshot)\n\n finally:\n sandbox.close()\n\nif __name__ == \"__main__\":\n demo_automation()\n```\n\n### Web Automation with Playwright\n\n```python\nfrom screenenv import Sandbox\n\ndef web_automation():\n sandbox = Sandbox(headless=True)\n\n try:\n # Open website\n sandbox.open(\"https://www.example.com\")\n\n # Take browser screenshot\n screenshot = sandbox.playwright_screenshot(full_page=True)\n with open(\"web_screenshot.png\", \"wb\") as f:\n f.write(screenshot)\n\n playwright_browser = sandbox.playwright_browser()\n\n finally:\n sandbox.close()\n```\n### Benefits\n\n- **Single Entry Point**: All services accessible through one port\n- **Clean URLs**: Organized by service type (`/api`, `/novnc`, `/browser`, `/mcp`)\n- **Load Balancing Ready**: Easy to add multiple backend instances\n\n## MCP Server Demo\n\n```bash\npython -m examples.mcp_server_demo # or sudo -E python -m examples.mcp_server_demo if not in docker group\n```\n\n## Sandbox Demo\n\n```bash\npython -m examples.sandbox_demo # or sudo -E python -m examples.sandbox_demo if not in docker group\n```\n\n## Computer Agent Demo\n\n```bash\ncd examples/computer_agent\npython app.py # or sudo -E python app.py if not in docker group\n```\n\n\n## System Requirements\n\n- **Docker**: Must be installed and running\n- **Python**: 3.10 or higher\n- **Playwright**: For web automation features\n- **Memory**: At least 4GB RAM recommended\n\n## Docker Image\n\nThe sandbox uses a custom Ubuntu 22.04 Docker image with:\n- XFCE4 desktop environment\n- VNC server for remote access\n- Google Chrome/Chromium browser\n- LibreOffice suite\n- Python development tools\n- MCP server support\n- Nginx reverse proxy\n\n### Docker Usage\n\n```bash\ndocker run -p7860:7860 amhma/ubuntu-desktop\n```\n\nvariables:\n- `-p7860:7860` - port forwarding (must match the ENDPOINT_PORT variable, default is 7860)\n- `-e DISPLAY=:1` - X11 display (default: :1)\n- `-e SCREEN_SIZE=1920x1080x24` - screen resolution and color depth (default: 1920x1080x24)\n- `-e SERVER_TYPE=mcp` - server type (default: mcp) values: mcp, fastapi\n- `-e DPI=96` - display DPI (default: 96)\n- `-e NOVNC_SERVER_ENABLED=true` - enable noVNC server (default: true)\n- `-e SESSION_PASSWORD=\"\"` - session password (default: empty)\n- `-e ENDPOINT_PORT=7860` - endpoint port (default: 7860)\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "A powerful Python library for creating and managing isolated desktop environments using Docker containers",
"version": "0.1.1",
"project_urls": {
"Homepage": "https://github.com/huggingface/screenenv",
"Repository": "https://github.com/huggingface/screenenv"
},
"split_keywords": [
"automation",
" desktop",
" docker",
" gui",
" playwright",
" sandbox"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "1b738e80aaf2456db663a0481d7bd27531f9180fa416fc7d30ddbd2a2b8bea00",
"md5": "7e29375221642a8ae98265b58cd06325",
"sha256": "d9e786e30b3c82fccdf716aaa0d1b588070d759ecdab20e732afae11ec8377be"
},
"downloads": -1,
"filename": "screenenv-0.1.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7e29375221642a8ae98265b58cd06325",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 30975,
"upload_time": "2025-07-09T21:45:27",
"upload_time_iso_8601": "2025-07-09T21:45:27.362978Z",
"url": "https://files.pythonhosted.org/packages/1b/73/8e80aaf2456db663a0481d7bd27531f9180fa416fc7d30ddbd2a2b8bea00/screenenv-0.1.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "80e8ff2c843ef483d760e6f47b1a6c8dca978f36f23547f1258a81e37ef3aea7",
"md5": "0d41ffa4ecd3403aad75d55c992cc082",
"sha256": "c110ce56079cca5200c350243321eb9028ad9868906c639d3adf18ea8879fb2c"
},
"downloads": -1,
"filename": "screenenv-0.1.1.tar.gz",
"has_sig": false,
"md5_digest": "0d41ffa4ecd3403aad75d55c992cc082",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 27597,
"upload_time": "2025-07-09T21:45:28",
"upload_time_iso_8601": "2025-07-09T21:45:28.867694Z",
"url": "https://files.pythonhosted.org/packages/80/e8/ff2c843ef483d760e6f47b1a6c8dca978f36f23547f1258a81e37ef3aea7/screenenv-0.1.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-09 21:45:28",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "huggingface",
"github_project": "screenenv",
"github_not_found": true,
"lcname": "screenenv"
}
