orgo 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

orgo/__init__.py

@@ -1,6 +1,7 @@
 # src/orgo/__init__.py
 """Orgo SDK: Desktop infrastructure for AI agents"""
 
+from .project import Project
 from .computer import Computer
 
-__all__ = ["Computer"]
+__all__ = ["Project", "Computer"]

orgo/api/client.py

@@ -1,7 +1,7 @@
 """API client for Orgo service"""
 
 import requests
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 
 from orgo.utils.auth import get_api_key
 
@@ -39,73 +39,99 @@ class ApiClient:
                 raise Exception(error_message) from e
             raise Exception(f"Connection error: {str(e)}") from e
     
-    # Computer lifecycle methods
-    def create_computer(self, config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Create a new project with desktop instance"""
-        payload = {}
-        if config:
-            payload["config"] = config
-        return self._request("POST", "projects", payload if payload else None)
-    
-    def connect_computer(self, project_id: str) -> Dict[str, Any]:
-        return self._request("GET", f"projects/by-name/{project_id}")
-    
-    def get_status(self, project_id: str) -> Dict[str, Any]:
-        return self._request("GET", f"projects/by-name/{project_id}")
-    
-    def start_computer(self, project_name: str) -> Dict[str, Any]:
-        # Get the actual project ID from the name
-        project = self.get_status(project_name)
-        project_id = project.get("id")
-        if not project_id:
-            raise ValueError(f"Could not find ID for project {project_name}")
+    # Project methods
+    def create_project(self, name: str) -> Dict[str, Any]:
+        """Create a new named project"""
+        return self._request("POST", "projects", {"name": name})
+    
+    def get_project_by_name(self, name: str) -> Dict[str, Any]:
+        """Get project details by name"""
+        return self._request("GET", f"projects/by-name/{name}")
+    
+    def get_project(self, project_id: str) -> Dict[str, Any]:
+        """Get project details by ID"""
+        return self._request("GET", f"projects/{project_id}")
+    
+    def list_projects(self) -> List[Dict[str, Any]]:
+        """List all projects"""
+        response = self._request("GET", "projects")
+        return response.get("projects", [])
+    
+    def start_project(self, project_id: str) -> Dict[str, Any]:
+        """Start a project"""
         return self._request("POST", f"projects/{project_id}/start")
     
-    def stop_computer(self, project_name: str) -> Dict[str, Any]:
-        # Get the actual project ID from the name
-        project = self.get_status(project_name)
-        project_id = project.get("id")
-        if not project_id:
-            raise ValueError(f"Could not find ID for project {project_name}")
+    def stop_project(self, project_id: str) -> Dict[str, Any]:
+        """Stop a project"""
         return self._request("POST", f"projects/{project_id}/stop")
     
-    def restart_computer(self, project_name: str) -> Dict[str, Any]:
-        # Get the actual project ID from the name
-        project = self.get_status(project_name)
-        project_id = project.get("id")
-        if not project_id:
-            raise ValueError(f"Could not find ID for project {project_name}")
+    def restart_project(self, project_id: str) -> Dict[str, Any]:
+        """Restart a project"""
         return self._request("POST", f"projects/{project_id}/restart")
     
-    def delete_computer(self, project_name: str) -> Dict[str, Any]:
-        # Get the actual project ID from the name
-        project = self.get_status(project_name)
-        project_id = project.get("id")
-        if not project_id:
-            raise ValueError(f"Could not find ID for project {project_name}")
+    def delete_project(self, project_id: str) -> Dict[str, Any]:
+        """Delete a project and all its computers"""
         return self._request("POST", f"projects/{project_id}/delete")
     
+    # Computer methods
+    def create_computer(self, project_name: str, computer_name: str, 
+                       os: str = "linux", ram: int = 2, cpu: int = 2, 
+                       gpu: str = "none") -> Dict[str, Any]:
+        """Create a new computer within a project"""
+        return self._request("POST", f"projects/{project_name}/computers", {
+            "name": computer_name,
+            "os": os,
+            "ram": ram,
+            "cpu": cpu,
+            "gpu": gpu
+        })
+    
+    def list_computers(self, project_name: str) -> List[Dict[str, Any]]:
+        """List all computers in a project"""
+        response = self._request("GET", f"projects/{project_name}/computers")
+        return response.get("computers", [])
+    
+    def get_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Get computer details"""
+        return self._request("GET", f"computers/{computer_id}")
+    
+    def delete_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Delete a computer"""
+        return self._request("DELETE", f"computers/{computer_id}")
+    
+    def start_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Start a computer"""
+        return self._request("POST", f"computers/{computer_id}/start")
+    
+    def stop_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Stop a computer"""
+        return self._request("POST", f"computers/{computer_id}/stop")
+    
+    def restart_computer(self, computer_id: str) -> Dict[str, Any]:
+        """Restart a computer"""
+        return self._request("POST", f"computers/{computer_id}/restart")
+    
     # Computer control methods
-    def left_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/click", {
+    def left_click(self, computer_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/click", {
             "button": "left", "x": x, "y": y
         })
     
-    def right_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/click", {
+    def right_click(self, computer_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/click", {
             "button": "right", "x": x, "y": y
         })
     
-    def double_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/click", {
+    def double_click(self, computer_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/click", {
             "button": "left", "x": x, "y": y, "double": True
         })
     
-    def drag(self, project_id: str, start_x: int, start_y: int, 
+    def drag(self, computer_id: str, start_x: int, start_y: int, 
              end_x: int, end_y: int, button: str = "left", 
              duration: float = 0.5) -> Dict[str, Any]:
         """Perform a drag operation from start to end coordinates"""
-        return self._request("POST", f"computers/{project_id}/drag", {
+        return self._request("POST", f"computers/{computer_id}/drag", {
             "start_x": start_x,
             "start_y": start_y,
             "end_x": end_x,
@@ -114,52 +140,52 @@ class ApiClient:
             "duration": duration
         })
     
-    def scroll(self, project_id: str, direction: str, amount: int) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/scroll", {
+    def scroll(self, computer_id: str, direction: str, amount: int = 3) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/scroll", {
             "direction": direction, "amount": amount
         })
     
-    def type_text(self, project_id: str, text: str) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/type", {
+    def type_text(self, computer_id: str, text: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/type", {
             "text": text
         })
     
-    def key_press(self, project_id: str, key: str) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/key", {
+    def key_press(self, computer_id: str, key: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/key", {
             "key": key
         })
     
-    def get_screenshot(self, project_id: str) -> Dict[str, Any]:
-        return self._request("GET", f"computers/{project_id}/screenshot")
+    def get_screenshot(self, computer_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{computer_id}/screenshot")
     
-    def execute_bash(self, project_id: str, command: str) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/bash", {
+    def execute_bash(self, computer_id: str, command: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/bash", {
             "command": command
         })
     
-    def execute_python(self, project_id: str, code: str, timeout: int = 10) -> Dict[str, Any]:
+    def execute_python(self, computer_id: str, code: str, timeout: int = 10) -> Dict[str, Any]:
         """Execute Python code on the computer"""
-        return self._request("POST", f"computers/{project_id}/exec", {
+        return self._request("POST", f"computers/{computer_id}/exec", {
             "code": code,
             "timeout": timeout
         })
     
-    def wait(self, project_id: str, seconds: float) -> Dict[str, Any]:
-        return self._request("POST", f"computers/{project_id}/wait", {
-            "seconds": seconds
+    def wait(self, computer_id: str, duration: float) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{computer_id}/wait", {
+            "duration": duration
         })
     
     # Streaming methods
-    def start_stream(self, project_id: str, connection_name: str) -> Dict[str, Any]:
+    def start_stream(self, computer_id: str, connection_name: str) -> Dict[str, Any]:
         """Start streaming to a configured RTMP connection"""
-        return self._request("POST", f"computers/{project_id}/stream/start", {
+        return self._request("POST", f"computers/{computer_id}/stream/start", {
             "connection_name": connection_name
         })
     
-    def stop_stream(self, project_id: str) -> Dict[str, Any]:
+    def stop_stream(self, computer_id: str) -> Dict[str, Any]:
         """Stop the active stream"""
-        return self._request("POST", f"computers/{project_id}/stream/stop")
+        return self._request("POST", f"computers/{computer_id}/stream/stop")
     
-    def get_stream_status(self, project_id: str) -> Dict[str, Any]:
+    def get_stream_status(self, computer_id: str) -> Dict[str, Any]:
         """Get current stream status"""
-        return self._request("GET", f"computers/{project_id}/stream/status")
+        return self._request("GET", f"computers/{computer_id}/stream/status")

orgo/computer.py

@@ -3,39 +3,52 @@ import os
 import io
 import base64
 import logging
-from typing import Dict, List, Any, Optional, Callable, Literal
+import uuid
+from typing import Dict, List, Any, Optional, Callable, Literal, Union
 from PIL import Image
 import requests
 from requests.exceptions import RequestException
 
 from .api.client import ApiClient
 from .prompt import get_provider
-from .project import ProjectManager
 
 logger = logging.getLogger(__name__)
 
 class Computer:
     def __init__(self, 
-                 project_id: Optional[str] = None, 
+                 project: Optional[Union[str, 'Project']] = None,
+                 name: Optional[str] = None,
+                 computer_id: Optional[str] = None,
                  api_key: Optional[str] = None, 
-                 config: Optional[Dict[str, Any]] = None, 
                  base_api_url: Optional[str] = None,
-                 ram: Optional[Literal[2, 4]] = None,
-                 memory: Optional[Literal[2, 4]] = None,
-                 cpu: Optional[Literal[2, 4]] = None):
+                 ram: Optional[Literal[1, 2, 4, 8, 16, 32, 64]] = None,
+                 memory: Optional[Literal[1, 2, 4, 8, 16, 32, 64]] = None,
+                 cpu: Optional[Literal[1, 2, 4, 8, 16]] = None,
+                 os: Optional[Literal["linux", "windows"]] = None,
+                 gpu: Optional[Literal["none", "a10", "l40s", "a100-40gb", "a100-80gb"]] = None):
         """
         Initialize an Orgo virtual computer.
         
         Args:
-            project_id: Existing project ID to connect to (optional)
+            project: Project name (str) or Project instance. If not provided, creates a new project.
+            name: Computer name within the project (optional, auto-generated if not provided)
+            computer_id: Existing computer ID to connect to (optional)
             api_key: Orgo API key (defaults to ORGO_API_KEY env var)
-            config: Configuration for new computer (optional)
             base_api_url: Custom API URL (optional)
-            ram: RAM in GB for new computer (2 or 4) - only used when creating
-            memory: Alternative parameter for RAM in GB (2 or 4) - only used when creating
-            cpu: CPU cores for new computer (2 or 4) - only used when creating
+            ram/memory: RAM in GB (1, 2, 4, 8, 16, 32, or 64) - only used when creating
+            cpu: CPU cores (1, 2, 4, 8, or 16) - only used when creating
+            os: Operating system ("linux" or "windows") - only used when creating
+            gpu: GPU type - only used when creating
         
-        Note: If both ram and memory are provided, ram takes precedence.
+        Examples:
+            # Create computer in new project
+            computer = Computer(ram=4, cpu=2)
+            
+            # Create computer in existing project
+            computer = Computer(project="manus", ram=4, cpu=2)
+            
+            # Connect to existing computer in project
+            computer = Computer(project="manus")
         """
         self.api_key = api_key or os.environ.get("ORGO_API_KEY")
         self.base_api_url = base_api_url
@@ -45,241 +58,246 @@ class Computer:
         if ram is None and memory is not None:
             ram = memory
         
-        # Look for a saved project ID if none was provided
-        if project_id is None:
-            project_id = ProjectManager.load_project_id()
+        # Store configuration
+        self.os = os or "linux"
+        self.ram = ram or 2
+        self.cpu = cpu or 2
+        self.gpu = gpu or "none"
         
-        if project_id:
-            try:
-                self.project_id = project_id
-                self._info = self.api.connect_computer(project_id)
-                # Log if ram/memory/cpu were provided but ignored
-                if ram is not None or memory is not None or cpu is not None:
-                    logger.info("Note: ram, memory, and cpu parameters are ignored when connecting to existing computer")
-            except (RequestException, ValueError) as e:
-                logger.warning(f"Could not connect to saved project {project_id}: {e}")
-                self._create_new_computer(config, ram, cpu)
+        if computer_id:
+            # Connect to existing computer by ID
+            self._connect_by_id(computer_id)
+        elif project:
+            # Work with specified project
+            if isinstance(project, str):
+                # Project name provided
+                self.project_name = project
+                self._initialize_with_project_name(project, name)
+            else:
+                # Project instance provided
+                from .project import Project as ProjectClass
+                if isinstance(project, ProjectClass):
+                    self.project_name = project.name
+                    self.project_id = project.id
+                    self._initialize_with_project_instance(project, name)
+                else:
+                    raise ValueError("project must be a string (project name) or Project instance")
         else:
-            self._create_new_computer(config, ram, cpu)
+            # No project specified, create a new one
+            self._create_new_project_and_computer(name)
+    
+    def _connect_by_id(self, computer_id: str):
+        """Connect to existing computer by ID"""
+        self.computer_id = computer_id
+        self._info = self.api.get_computer(computer_id)
+        self.project_name = self._info.get("project_name")
+        self.name = self._info.get("name")
+    
+    def _initialize_with_project_name(self, project_name: str, computer_name: Optional[str]):
+        """Initialize with a project name (create project if needed)"""
+        try:
+            # Try to get existing project
+            project = self.api.get_project_by_name(project_name)
+            self.project_id = project.get("id")
+            
+            # Check for existing computers
+            computers = self.api.list_computers(project_name)
             
-    def _create_new_computer(self, config: Optional[Dict[str, Any]] = None, 
-                           ram: Optional[Literal[2, 4]] = None,
-                           cpu: Optional[Literal[2, 4]] = None):
-        """Create a new computer instance and save its ID"""
-        # Validate ram and cpu values if provided
-        if ram is not None and ram not in [2, 4]:
-            raise ValueError("ram/memory must be either 2 or 4 GB")
-        if cpu is not None and cpu not in [2, 4]:
-            raise ValueError("cpu must be either 2 or 4 cores")
+            if computer_name:
+                # Look for specific computer
+                existing = next((c for c in computers if c.get("name") == computer_name), None)
+                if existing:
+                    self._connect_to_existing_computer(existing)
+                else:
+                    # Create new computer with specified name
+                    self._create_computer(project_name, computer_name)
+            elif computers:
+                # No name specified, use first available computer
+                self._connect_to_existing_computer(computers[0])
+            else:
+                # No computers exist, create new one
+                self._create_computer(project_name, computer_name)
+                
+        except Exception:
+            # Project doesn't exist, create it
+            logger.info(f"Project {project_name} not found, creating new project")
+            project = self.api.create_project(project_name)
+            self.project_id = project.get("id")
+            self._create_computer(project_name, computer_name)
+    
+    def _initialize_with_project_instance(self, project: 'Project', computer_name: Optional[str]):
+        """Initialize with a Project instance"""
+        computers = project.list_computers()
         
-        # Build the config with ram and cpu if provided
-        if ram is not None or cpu is not None:
-            if config is None:
-                config = {}
+        if computer_name:
+            # Look for specific computer
+            existing = next((c for c in computers if c.get("name") == computer_name), None)
+            if existing:
+                self._connect_to_existing_computer(existing)
             else:
-                # Make a copy to avoid modifying the original
-                config = config.copy()
-            
-            # Add ram and cpu to config
-            if ram is not None:
-                config['ram'] = ram
-            if cpu is not None:
-                config['cpu'] = cpu
+                # Create new computer with specified name
+                self._create_computer(project.name, computer_name)
+        elif computers:
+            # No name specified, use first available computer
+            self._connect_to_existing_computer(computers[0])
+        else:
+            # No computers exist, create new one
+            self._create_computer(project.name, computer_name)
+    
+    def _create_new_project_and_computer(self, computer_name: Optional[str]):
+        """Create a new project and computer"""
+        # Generate a unique project name
+        project_name = f"project-{uuid.uuid4().hex[:8]}"
         
-        response = self.api.create_computer(config)
-        self.project_id = response.get("name")
-        self._info = response
+        # Create the project
+        project = self.api.create_project(project_name)
+        self.project_id = project.get("id")
+        self.project_name = project_name
         
-        if not self.project_id:
-            raise ValueError("Failed to initialize computer: No project ID returned")
-            
-        # Save the project ID for future use
-        ProjectManager.save_project_id(self.project_id)
+        # Create a computer in the new project
+        self._create_computer(project_name, computer_name)
+    
+    def _connect_to_existing_computer(self, computer_info: Dict[str, Any]):
+        """Connect to an existing computer"""
+        self.computer_id = computer_info.get("id")
+        self.name = computer_info.get("name")
+        self._info = computer_info
+        logger.info(f"Connected to existing computer {self.name} (ID: {self.computer_id})")
+    
+    def _create_computer(self, project_name: str, computer_name: Optional[str]):
+        """Create a new computer in the project"""
+        # Generate name if not provided
+        if not computer_name:
+            computer_name = f"desktop-{uuid.uuid4().hex[:8]}"
+        
+        self.name = computer_name
+        
+        # Validate parameters
+        if self.ram not in [1, 2, 4, 8, 16, 32, 64]:
+            raise ValueError("ram must be one of: 1, 2, 4, 8, 16, 32, 64 GB")
+        if self.cpu not in [1, 2, 4, 8, 16]:
+            raise ValueError("cpu must be one of: 1, 2, 4, 8, 16 cores")
+        if self.os not in ["linux", "windows"]:
+            raise ValueError("os must be either 'linux' or 'windows'")
+        if self.gpu not in ["none", "a10", "l40s", "a100-40gb", "a100-80gb"]:
+            raise ValueError("gpu must be one of: 'none', 'a10', 'l40s', 'a100-40gb', 'a100-80gb'")
+        
+        computer = self.api.create_computer(
+            project_name=project_name,
+            computer_name=computer_name,
+            os=self.os,
+            ram=self.ram,
+            cpu=self.cpu,
+            gpu=self.gpu
+        )
+        self.computer_id = computer.get("id")
+        self._info = computer
+        logger.info(f"Created new computer {self.name} (ID: {self.computer_id})")
     
     def status(self) -> Dict[str, Any]:
         """Get current computer status"""
-        return self.api.get_status(self.project_id)
+        return self.api.get_computer(self.computer_id)
     
     def start(self) -> Dict[str, Any]:
         """Start the computer"""
-        return self.api.start_computer(self.project_id)
+        return self.api.start_computer(self.computer_id)
     
     def stop(self) -> Dict[str, Any]:
         """Stop the computer"""
-        return self.api.stop_computer(self.project_id)
+        return self.api.stop_computer(self.computer_id)
     
     def restart(self) -> Dict[str, Any]:
         """Restart the computer"""
-        return self.api.restart_computer(self.project_id)
+        return self.api.restart_computer(self.computer_id)
     
     def destroy(self) -> Dict[str, Any]:
         """Terminate and delete the computer instance"""
-        result = self.api.delete_computer(self.project_id)
-        # Clear the local project cache after destroying
-        ProjectManager.clear_project_cache()
-        return result
+        return self.api.delete_computer(self.computer_id)
     
     # Navigation methods
     def left_click(self, x: int, y: int) -> Dict[str, Any]:
         """Perform left mouse click at specified coordinates"""
-        return self.api.left_click(self.project_id, x, y)
+        return self.api.left_click(self.computer_id, x, y)
     
     def right_click(self, x: int, y: int) -> Dict[str, Any]:
         """Perform right mouse click at specified coordinates"""
-        return self.api.right_click(self.project_id, x, y)
+        return self.api.right_click(self.computer_id, x, y)
     
     def double_click(self, x: int, y: int) -> Dict[str, Any]:
         """Perform double click at specified coordinates"""
-        return self.api.double_click(self.project_id, x, y)
+        return self.api.double_click(self.computer_id, x, y)
     
     def drag(self, start_x: int, start_y: int, end_x: int, end_y: int, 
              button: str = "left", duration: float = 0.5) -> Dict[str, Any]:
-        """
-        Perform a smooth drag operation from start to end coordinates.
-        
-        Args:
-            start_x: Starting X coordinate
-            start_y: Starting Y coordinate
-            end_x: Ending X coordinate
-            end_y: Ending Y coordinate
-            button: Mouse button to use ("left" or "right", default: "left")
-            duration: Duration of the drag in seconds (0.1 to 5.0, default: 0.5)
-            
-        Returns:
-            Dict with operation result
-        """
-        return self.api.drag(self.project_id, start_x, start_y, end_x, end_y, button, duration)
+        """Perform a smooth drag operation from start to end coordinates"""
+        return self.api.drag(self.computer_id, start_x, start_y, end_x, end_y, button, duration)
     
-    def scroll(self, direction: str = "down", amount: int = 1) -> Dict[str, Any]:
+    def scroll(self, direction: str = "down", amount: int = 3) -> Dict[str, Any]:
         """Scroll in specified direction and amount"""
-        return self.api.scroll(self.project_id, direction, amount)
+        return self.api.scroll(self.computer_id, direction, amount)
     
     # Input methods
     def type(self, text: str) -> Dict[str, Any]:
         """Type the specified text"""
-        return self.api.type_text(self.project_id, text)
+        return self.api.type_text(self.computer_id, text)
     
     def key(self, key: str) -> Dict[str, Any]:
         """Press a key or key combination (e.g., "Enter", "ctrl+c")"""
-        return self.api.key_press(self.project_id, key)
+        return self.api.key_press(self.computer_id, key)
     
     # View methods
     def screenshot(self) -> Image.Image:
         """Capture screenshot and return as PIL Image"""
-        response = self.api.get_screenshot(self.project_id)
+        response = self.api.get_screenshot(self.computer_id)
         image_data = response.get("image", "")
         
-        # Check if it's a URL (new format) or base64 (legacy format)
         if image_data.startswith(('http://', 'https://')):
-            # Download image from URL
             img_response = requests.get(image_data)
             img_response.raise_for_status()
             return Image.open(io.BytesIO(img_response.content))
         else:
-            # Legacy base64 format
             img_data = base64.b64decode(image_data)
             return Image.open(io.BytesIO(img_data))
     
     def screenshot_base64(self) -> str:
         """Capture screenshot and return as base64 string"""
-        response = self.api.get_screenshot(self.project_id)
+        response = self.api.get_screenshot(self.computer_id)
         image_data = response.get("image", "")
         
-        # Check if it's a URL (new format) or base64 (legacy format)
         if image_data.startswith(('http://', 'https://')):
-            # Download image from URL and convert to base64
             img_response = requests.get(image_data)
             img_response.raise_for_status()
             return base64.b64encode(img_response.content).decode('utf-8')
         else:
-            # Already base64
             return image_data
     
     # Execution methods
     def bash(self, command: str) -> str:
         """Execute a bash command and return output"""
-        response = self.api.execute_bash(self.project_id, command)
+        response = self.api.execute_bash(self.computer_id, command)
         return response.get("output", "")
     
     def exec(self, code: str, timeout: int = 10) -> Dict[str, Any]:
-        """
-        Execute Python code on the remote computer.
-        
-        Args:
-            code: Python code to execute
-            timeout: Maximum execution time in seconds (default: 10, max: 300)
-            
-        Returns:
-            Dict with keys:
-            - success: bool indicating if execution completed without errors
-            - output: str containing stdout output
-            - error: str containing error message if any
-            - error_type: str with exception type name if error occurred
-            - timeout: bool indicating if execution timed out
-            
-        Example:
-            result = computer.exec('''
-import os
-print(f"Current directory: {os.getcwd()}")
-print(f"Files: {os.listdir('.')}")
-            ''')
-            
-            if result['success']:
-                print(result['output'])
-            else:
-                print(f"Error: {result['error']}")
-        """
-        response = self.api.execute_python(self.project_id, code, timeout)
+        """Execute Python code on the remote computer"""
+        response = self.api.execute_python(self.computer_id, code, timeout)
         return response
     
     def wait(self, seconds: float) -> Dict[str, Any]:
         """Wait for specified number of seconds"""
-        return self.api.wait(self.project_id, seconds)
+        return self.api.wait(self.computer_id, seconds)
     
     # Streaming methods
     def start_stream(self, connection: str) -> Dict[str, Any]:
-        """
-        Start streaming the computer screen to an RTMP server.
-        
-        Args:
-            connection: Name of the RTMP connection configured in settings (e.g., "my-twitch-1")
-            
-        Returns:
-            Dict with streaming status information
-            
-        Example:
-            # First configure a connection in settings at https://www.orgo.ai/settings
-            # Then start streaming
-            computer.start_stream("my-twitch-1")
-            
-            # Do your demo/automation
-            computer.type("Hello viewers!")
-            
-            # Stop streaming when done
-            computer.stop_stream()
-        """
-        return self.api.start_stream(self.project_id, connection)
+        """Start streaming the computer screen to an RTMP server"""
+        return self.api.start_stream(self.computer_id, connection)
     
     def stop_stream(self) -> Dict[str, Any]:
-        """
-        Stop the active stream.
-        
-        Returns:
-            Dict with stop status information
-        """
-        return self.api.stop_stream(self.project_id)
+        """Stop the active stream"""
+        return self.api.stop_stream(self.computer_id)
     
     def stream_status(self) -> Dict[str, Any]:
-        """
-        Get the current streaming status.
-        
-        Returns:
-            Dict with keys:
-            - status: "idle", "streaming", or "terminated"
-            - start_time: ISO timestamp when stream started (if streaming)
-            - pid: Process ID of ffmpeg (if streaming)
-        """
-        return self.api.get_stream_status(self.project_id)
+        """Get the current streaming status"""
+        return self.api.get_stream_status(self.computer_id)
     
     # AI control method
     def prompt(self, 
@@ -295,32 +313,11 @@ print(f"Files: {os.listdir('.')}")
                max_iterations: int = 20,
                max_saved_screenshots: int = 5,
                api_key: Optional[str] = None) -> List[Dict[str, Any]]:
-        """
-        Control the computer with natural language instructions using an AI assistant.
-        
-        Args:
-            instruction: What you want the AI to do with the computer
-            provider: AI provider to use (default: "anthropic")
-            model: Model to use (default: "claude-3-7-sonnet-20250219")
-            display_width: Screen width in pixels
-            display_height: Screen height in pixels
-            callback: Optional callback function for progress updates
-            thinking_enabled: Enable Claude's thinking capability (default: False)
-            thinking_budget: Token budget for thinking (default: 1024)
-            max_tokens: Maximum tokens for model response
-            max_iterations: Maximum number of agent loop iterations
-            max_saved_screenshots: Maximum number of screenshots to keep in history (default: 5)
-            api_key: API key for the AI provider (defaults to env var)
-            
-        Returns:
-            List of messages from the conversation
-        """
-        # Get the provider instance
+        """Control the computer with natural language instructions using an AI assistant"""
         provider_instance = get_provider(provider)
         
-        # Execute the prompt
         return provider_instance.execute(
-            computer_id=self.project_id,
+            computer_id=self.computer_id,
             instruction=instruction,
             callback=callback,
             api_key=api_key,
@@ -332,7 +329,9 @@ print(f"Files: {os.listdir('.')}")
             max_tokens=max_tokens,
             max_iterations=max_iterations,
             max_saved_screenshots=max_saved_screenshots,
-            # Pass through the Orgo API client configuration
             orgo_api_key=self.api_key,
             orgo_base_url=self.base_api_url
-        )
+        )
+    
+    def __repr__(self):
+        return f"Computer(name='{self.name}', project='{self.project_name}', id='{self.computer_id}')"

orgo/project.py

@@ -1,64 +1,87 @@
-# src/orgo/project.py
-"""Project management for Orgo virtual environments"""
+"""Project class for managing Orgo projects"""
 import os
-import json
-import shutil
-import logging
-from typing import Optional
+import uuid
+from typing import Dict, List, Any, Optional
 
-logger = logging.getLogger(__name__)
+from .api.client import ApiClient
 
-class ProjectManager:
-    """Manages project persistence for Orgo computers"""
-    
-    @staticmethod
-    def load_project_id() -> Optional[str]:
-        """Load project ID from local config file"""
-        config_path = ProjectManager._get_config_path()
+class Project:
+    def __init__(self, 
+                 name: Optional[str] = None,
+                 api_key: Optional[str] = None,
+                 base_api_url: Optional[str] = None):
+        """
+        Initialize an Orgo project.
         
-        if not os.path.exists(config_path):
-            return None
-            
-        try:
-            with open(config_path, 'r') as f:
-                data = json.load(f)
-                return data.get('project_id')
-        except (json.JSONDecodeError, IOError, OSError) as e:
-            logger.warning(f"Error loading project config: {str(e)}")
-            return None
-    
-    @staticmethod
-    def save_project_id(project_id: str) -> None:
-        """Save project ID to local config file"""
-        config_dir = ProjectManager._get_project_dir()
-        config_path = ProjectManager._get_config_path()
+        Args:
+            name: Project name. If exists, connects to it. If not, creates it.
+            api_key: Orgo API key (defaults to ORGO_API_KEY env var)
+            base_api_url: Custom API URL (optional)
+        """
+        self.api_key = api_key or os.environ.get("ORGO_API_KEY")
+        self.base_api_url = base_api_url
+        self.api = ApiClient(self.api_key, self.base_api_url)
+        
+        if name:
+            self.name = name
+        else:
+            # Generate a unique name if not provided
+            self.name = f"project-{uuid.uuid4().hex[:8]}"
         
+        # Try to get existing project or create new one
+        self._initialize_project()
+    
+    def _initialize_project(self):
+        """Get existing project or create new one"""
         try:
-            os.makedirs(config_dir, exist_ok=True)
-            with open(config_path, 'w') as f:
-                json.dump({'project_id': project_id}, f, indent=2)
-        except (IOError, OSError) as e:
-            logger.error(f"Failed to save project ID: {str(e)}")
-            raise RuntimeError(f"Failed to save project configuration: {str(e)}") from e
+            # Try to get existing project
+            project = self.api.get_project_by_name(self.name)
+            self.id = project.get("id")
+            self._info = project
+        except Exception:
+            # Project doesn't exist, create it
+            project = self.api.create_project(self.name)
+            self.id = project.get("id")
+            self._info = project
     
-    @staticmethod
-    def clear_project_cache() -> None:
-        """Clear the .orgo folder and all its contents"""
-        project_dir = ProjectManager._get_project_dir()
-        
-        if os.path.exists(project_dir):
-            try:
-                shutil.rmtree(project_dir)
-                logger.info(f"Cleared project cache at {project_dir}")
-            except (IOError, OSError) as e:
-                logger.warning(f"Failed to clear project cache: {str(e)}")
+    def status(self) -> Dict[str, Any]:
+        """Get project status"""
+        return self.api.get_project(self.id)
     
-    @staticmethod
-    def _get_project_dir() -> str:
-        """Get the project directory path"""
-        return os.path.join(os.getcwd(), ".orgo")
+    def start(self) -> Dict[str, Any]:
+        """Start all computers in the project"""
+        return self.api.start_project(self.id)
+    
+    def stop(self) -> Dict[str, Any]:
+        """Stop all computers in the project"""
+        return self.api.stop_project(self.id)
+    
+    def restart(self) -> Dict[str, Any]:
+        """Restart all computers in the project"""
+        return self.api.restart_project(self.id)
+    
+    def destroy(self) -> Dict[str, Any]:
+        """Delete the project and all its computers"""
+        return self.api.delete_project(self.id)
+    
+    def list_computers(self) -> List[Dict[str, Any]]:
+        """List all computers in this project"""
+        return self.api.list_computers(self.name)
+    
+    def get_computer(self, computer_name: str = None) -> Optional[Dict[str, Any]]:
+        """Get a specific computer in this project by name, or the first one if no name specified"""
+        computers = self.list_computers()
+        if not computers:
+            return None
+        
+        if computer_name:
+            for computer in computers:
+                if computer.get("name") == computer_name:
+                    return computer
+            return None
+        else:
+            # Return first computer if no name specified
+            return computers[0]
     
-    @staticmethod
-    def _get_config_path() -> str:
-        """Get the full path to the config file"""
-        return os.path.join(ProjectManager._get_project_dir(), "project.json")
+    def __repr__(self):
+        return f"Project(name='{self.name}', id='{self.id}')"

{orgo-0.0.24.dist-info → orgo-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.24
+Version: 0.0.26
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT

orgo-0.0.26.dist-info/RECORD

@@ -0,0 +1,12 @@
+orgo/__init__.py,sha256=aw3BM7-Wy8jk-mvIWRG2gC4-nsc74s6ZFm1U21NyGeM,171
+orgo/computer.py,sha256=w_Cvjw1pspkV14CodgNJpDvYAOvL3tS6KfDiUsEcC3s,14463
+orgo/project.py,sha256=u6kxoUUj9xAxzVWl2A4kD4EHmQWrrwTixkIVRhH4Ehc,3072
+orgo/prompt.py,sha256=ynblwXPTDp_aF1MbGBsY0PIEr9naklDaKFcfSE_EZ6E,19781
+orgo/api/__init__.py,sha256=9Tzb_OPJ5DH7Cg7OrHzpZZUT4ip05alpa9RLDYmnId8,113
+orgo/api/client.py,sha256=JofBHTnks4nO60786vAmzJmECVFFf-Yff1qF0ir-YQ8,7958
+orgo/utils/__init__.py,sha256=W4G_nwGBf_7jy0w_mfcrkllurYHSRU4B5cMTVYH_uCc,123
+orgo/utils/auth.py,sha256=tPLBJY-6gdBQWLUjUbwIwxHphC3KoRT_XgP3Iykw3Mw,509
+orgo-0.0.26.dist-info/METADATA,sha256=o92pMm2FgkRbLYQzgw_LLLRgpiJvyDBjdT7M-ug1m9w,822
+orgo-0.0.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orgo-0.0.26.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
+orgo-0.0.26.dist-info/RECORD,,

orgo-0.0.24.dist-info/RECORD

@@ -1,12 +0,0 @@
-orgo/__init__.py,sha256=TlOzDJqRKotAam631MdZcz8ypAqyWrLo-Px8HWLkrD0,131
-orgo/computer.py,sha256=44jqFqANITalNt-7hsDn-UKVJZCyqR-63wrxAyTnpmw,13629
-orgo/project.py,sha256=F90mYJKRZAoFSFw8HVAiosMoLyzVlf0QaKJgTyXoJ4A,2267
-orgo/prompt.py,sha256=ynblwXPTDp_aF1MbGBsY0PIEr9naklDaKFcfSE_EZ6E,19781
-orgo/api/__init__.py,sha256=9Tzb_OPJ5DH7Cg7OrHzpZZUT4ip05alpa9RLDYmnId8,113
-orgo/api/client.py,sha256=MgOg5shKzsOVsablvtTa39_ms-OdrmFMW1pD07C6PTs,7045
-orgo/utils/__init__.py,sha256=W4G_nwGBf_7jy0w_mfcrkllurYHSRU4B5cMTVYH_uCc,123
-orgo/utils/auth.py,sha256=tPLBJY-6gdBQWLUjUbwIwxHphC3KoRT_XgP3Iykw3Mw,509
-orgo-0.0.24.dist-info/METADATA,sha256=uidJBILPzxo19T-6DJS6xYb8JSqSMfxuEU8113xAQMA,822
-orgo-0.0.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orgo-0.0.24.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
-orgo-0.0.24.dist-info/RECORD,,