orgo 0.0.32__py3-none-any.whl → 0.0.35__py3-none-any.whl

orgo/__init__.py

@@ -3,5 +3,6 @@
 
 from .project import Project
 from .computer import Computer
+from .forge import Forge
 
-__all__ = ["Project", "Computer"]
+__all__ = ["Project", "Computer", "Forge"]

orgo/api/client.py

@@ -28,6 +28,11 @@ class ApiClient:
             else:
                 response = self.session.request(method, url, json=data)
             
+            # Handle 405 specifically for better debugging
+            if response.status_code == 405:
+                logger.error(f"Method Not Allowed: {method} {url}")
+                logger.error(f"Response: {response.text}")
+            
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -75,16 +80,20 @@ class ApiClient:
     # Computer methods
     def create_computer(self, project_id: str, computer_name: str, 
                        os: str = "linux", ram: int = 2, cpu: int = 2, 
-                       gpu: str = "none") -> Dict[str, Any]:
+                       gpu: str = "none", image: Optional[str] = None) -> Dict[str, Any]:
         """Create a new computer within a project"""
-        return self._request("POST", "computers", {
+        data = {
             "project_id": project_id,
             "name": computer_name,
             "os": os,
             "ram": ram,
             "cpu": cpu,
             "gpu": gpu
-        })
+        }
+        if image:
+            data["image"] = image
+            
+        return self._request("POST", "computers", data)
     
     def list_computers(self, project_id: str) -> List[Dict[str, Any]]:
         """List all computers in a project"""
@@ -180,4 +189,39 @@ class ApiClient:
     
     def get_stream_status(self, computer_id: str) -> Dict[str, Any]:
         """Get current stream status"""
-        return self._request("GET", f"computers/{computer_id}/stream/status")
+        return self._request("GET", f"computers/{computer_id}/stream/status")
+
+    # Build methods
+    def create_build(self, org_id: str, project_id: str, name: Optional[str] = None) -> Dict[str, Any]:
+        """Register a new build"""
+        data = {
+            "orgId": org_id,
+            "projectId": project_id
+        }
+        if name:
+            data["name"] = name
+            
+        return self._request("POST", "builds/create", data)
+
+    def get_latest_build(self, org_id: str, project_id: str, name: str) -> Dict[str, Any]:
+        """Get latest completed build by name"""
+        return self._request("GET", "builds/latest", {
+            "orgId": org_id,
+            "projectId": project_id,
+            "name": name
+        })
+
+    def update_build(self, build_id: str, status: str, 
+                     error_message: Optional[str] = None, 
+                     build_log: Optional[str] = None) -> Dict[str, Any]:
+        """Update build status"""
+        data = {
+            "buildId": build_id,
+            "status": status
+        }
+        if error_message:
+            data["errorMessage"] = error_message
+        if build_log:
+            data["buildLog"] = build_log
+            
+        return self._request("POST", "builds/update", data)

orgo/computer.py

@@ -25,7 +25,8 @@ class Computer:
                  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):
+                 gpu: Optional[Literal["none", "a10", "l40s", "a100-40gb", "a100-80gb"]] = None,
+                 image: Optional[Union[str, Any]] = None):
         """
         Initialize an Orgo virtual computer.
         
@@ -39,11 +40,16 @@ class Computer:
             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
+            image: Custom image reference (str) or Forge object - only used when creating
         
         Examples:
             # Create computer in new project
             computer = Computer(ram=4, cpu=2)
             
+            # Create computer with custom image
+            forge = Forge(org_id="myorg", project_id="myproj").base("ubuntu").run("echo hello")
+            computer = Computer(image=forge)
+            
             # Create computer in existing project
             computer = Computer(project="manus", ram=4, cpu=2)
             
@@ -64,7 +70,14 @@ class Computer:
         self.cpu = cpu or 2
         self.gpu = gpu or "none"
         
+        # Handle image
+        self.image = image
+        if hasattr(self.image, 'build') and callable(self.image.build):
+            logger.info("Building image from Forge object...")
+            self.image = self.image.build()
+        
         if computer_id:
+
             # Just store the computer ID, no API call needed
             self.computer_id = computer_id
             self.name = name
@@ -177,6 +190,28 @@ class Computer:
             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'")
+            
+        # Resolve image name if needed
+        image_ref = self.image
+        if image_ref and isinstance(image_ref, str) and not image_ref.startswith("registry.fly.io"):
+            logger.info(f"Resolving image name '{image_ref}'...")
+            try:
+                # Try to get org_id from project info
+                project_info = self.api.get_project(project_id)
+                org_id = project_info.get("org_id", "orgo") # Default to 'orgo'
+                
+                response = self.api.get_latest_build(org_id, project_id, image_ref)
+                if response and response.get("build"):
+                    resolved_ref = response.get("build", {}).get("imageRef")
+                    if resolved_ref:
+                        logger.info(f"Resolved '{image_ref}' to '{resolved_ref}'")
+                        image_ref = resolved_ref
+                    else:
+                        logger.warning(f"Build found for '{image_ref}' but no imageRef present.")
+                else:
+                    logger.warning(f"Could not resolve image name '{self.image}'. Using as is.")
+            except Exception as e:
+                logger.warning(f"Failed to resolve image name: {e}")
         
         computer = self.api.create_computer(
             project_id=project_id,
@@ -184,7 +219,8 @@ class Computer:
             os=self.os,
             ram=self.ram,
             cpu=self.cpu,
-            gpu=self.gpu
+            gpu=self.gpu,
+            image=image_ref
         )
         self.computer_id = computer.get("id")
         logger.info(f"Created new computer {self.name} (ID: {self.computer_id})")
@@ -290,15 +326,15 @@ class Computer:
     def prompt(self, 
                instruction: str,
                provider: str = "anthropic",
-               model: str = "claude-3-7-sonnet-20250219",
+               model: str = "claude-sonnet-4-5-20250929",
                display_width: int = 1024,
                display_height: int = 768,
                callback: Optional[Callable[[str, Any], None]] = None,
-               thinking_enabled: bool = False,
+               thinking_enabled: bool = True,
                thinking_budget: int = 1024,
                max_tokens: int = 4096,
-               max_iterations: int = 20,
-               max_saved_screenshots: int = 5,
+               max_iterations: int = 100,
+               max_saved_screenshots: int = 3,
                api_key: Optional[str] = None) -> List[Dict[str, Any]]:
         """Control the computer with natural language instructions using an AI assistant"""
         provider_instance = get_provider(provider)

orgo/forge.py

@@ -0,0 +1,176 @@
+import os
+import subprocess
+import logging
+from typing import Optional, List, Union
+import uuid
+
+from .api.client import ApiClient
+
+logger = logging.getLogger(__name__)
+
+class Forge:
+    def __init__(self, 
+                 org_id: str, 
+                 project_id: str, 
+                 name: Optional[str] = None,
+                 api_key: Optional[str] = None, 
+                 base_api_url: Optional[str] = None):
+        """
+        Initialize Orgo Forge for building images.
+        
+        Args:
+            org_id: Organization ID
+            project_id: Project ID
+            name: Optional friendly name for the image (not used for registry tag currently, but for reference)
+            api_key: Orgo API key
+            base_api_url: Custom API URL
+        """
+        self.org_id = org_id
+        self.project_id = project_id
+        self.name = name
+        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)
+        
+        # Enforce base image
+        self.steps: List[str] = ["FROM registry.fly.io/orgo-image-repo:latest"]
+        
+    def base(self, image: str) -> 'Forge':
+        """
+        DEPRECATED: Base image is now enforced to ensure CUA functionality.
+        This method will log a warning and ignore the provided image.
+        """
+        logger.warning("Forge.base() is deprecated. The base image is enforced to 'registry.fly.io/orgo-image-repo:latest'. Ignoring provided image.")
+        return self
+        
+    def run(self, command: str) -> 'Forge':
+        """Run a command (RUN instruction)"""
+        self.steps.append(f"RUN {command}")
+        return self
+        
+    def copy(self, src: str, dest: str) -> 'Forge':
+        """Copy files (COPY instruction)"""
+        self.steps.append(f"COPY {src} {dest}")
+        return self
+        
+    def git_clone(self, url: str, dest: str) -> 'Forge':
+        """Clone a git repository"""
+        # Ensure git is installed or use a base image with git
+        self.steps.append(f"RUN git clone {url} {dest}")
+        return self
+        
+    def env(self, key: str, value: str) -> 'Forge':
+        """Set environment variable (ENV instruction)"""
+        self.steps.append(f"ENV {key}={value}")
+        return self
+        
+    def workdir(self, path: str) -> 'Forge':
+        """Set working directory (WORKDIR instruction)"""
+        self.steps.append(f"WORKDIR {path}")
+        return self
+
+    def build(self, context_path: str = ".", push: bool = True) -> str:
+        """
+        Execute the build.
+        
+        1. Registers build with Orgo API to get unique tag.
+        2. Generates Dockerfile.
+        3. Runs docker build (requires docker CLI installed).
+        4. Pushes to registry.
+        5. Updates build status.
+        
+        Returns:
+            str: The full image reference (e.g. registry.fly.io/app:tag)
+        """
+        if not self.steps:
+            raise ValueError("No build steps defined. Use .base() to start.")
+            
+        # 1. Register build
+        logger.info("Registering build with Orgo API...")
+        try:
+            build_info = self.api.create_build(self.org_id, self.project_id, self.name)
+            build_data = build_info.get('build', {})
+            
+            build_id = build_data.get('id')
+            tag = build_data.get('tag')
+            image_ref = build_data.get('imageRef')
+            # buildkit_url = build_data.get('buildkitUrl') # Not used for local docker build yet
+            
+            if not build_id or not image_ref:
+                raise ValueError("Failed to get build ID or image ref from API")
+                
+            logger.info(f"Build registered. ID: {build_id}, Tag: {tag}")
+            logger.info(f"Target Image: {image_ref}")
+            
+        except Exception as e:
+            logger.error(f"Failed to register build: {e}")
+            raise e
+
+        # 2. Generate Dockerfile
+        dockerfile_path = f"Dockerfile.{tag}"
+        try:
+            with open(dockerfile_path, "w") as f:
+                f.write("\n".join(self.steps))
+                
+            # 3. Execute Build
+            logger.info("Starting build...")
+            self.api.update_build(build_id, "building")
+            
+            # Use remote builder
+            builder_name = "orgo-remote"
+            remote_url = "tcp://orgoforge.fly.dev:1234"
+            
+            # Check if builder exists
+            try:
+                subprocess.run(["docker", "buildx", "inspect", builder_name], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            except subprocess.CalledProcessError:
+                logger.info(f"Creating remote builder '{builder_name}' pointing to {remote_url}...")
+                subprocess.run(["docker", "buildx", "create", "--name", builder_name, "--driver", "remote", remote_url, "--use"], check=True)
+                subprocess.run(["docker", "buildx", "inspect", "--bootstrap"], check=True)
+
+            cmd = ["docker", "buildx", "build", "--builder", builder_name, "-t", image_ref, "-f", dockerfile_path, context_path]
+            if push:
+                cmd.append("--push")
+            
+            # Run build
+            process = subprocess.Popen(
+                cmd, 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.STDOUT, 
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            logs = []
+            while True:
+                line = process.stdout.readline()
+                if not line and process.poll() is not None:
+                    break
+                if line:
+                    print(line, end="") # Stream to console
+                    logs.append(line)
+            
+            if process.returncode != 0:
+                raise Exception(f"Docker build failed with exit code {process.returncode}")
+                
+            # 5. Report Success
+            full_log = "".join(logs)
+            self.api.update_build(build_id, "completed", build_log=full_log)
+            logger.info("Build completed successfully!")
+            
+            return image_ref
+
+        except Exception as e:
+            logger.error(f"Build failed: {e}")
+            full_log = "".join(logs) if 'logs' in locals() else str(e)
+            try:
+                self.api.update_build(build_id, "failed", error_message=str(e), build_log=full_log)
+            except:
+                pass # Ignore error reporting failure
+            raise e
+            
+        finally:
+            if os.path.exists(dockerfile_path):
+                os.remove(dockerfile_path)
+

orgo/project.py

@@ -66,7 +66,7 @@ class Project:
     
     def list_computers(self) -> List[Dict[str, Any]]:
         """List all computers in this project"""
-        return self.api.list_computers(self.name)
+        return self.api.list_computers(self.id)
     
     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"""

{orgo-0.0.32.dist-info → orgo-0.0.35.dist-info}/METADATA

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

orgo-0.0.35.dist-info/RECORD

@@ -0,0 +1,13 @@
+orgo/__init__.py,sha256=7uMYbhVNVUtrH7mCd8Ofll36EIdR92LcVlF7bdKuVR4,206
+orgo/computer.py,sha256=mRNIxBo9wtX6wIMfEAuQIjU220BmfCpUr6Kf1nFqwQ8,16100
+orgo/forge.py,sha256=Ey_X3tZwlgHPCSBYBIxPInNaERARoDZQ3vxjvOBLn_I,6714
+orgo/project.py,sha256=Abn58FKAL3vety-MzHJDR-G0GFnEDSD_ljTYnXp9e1I,3148
+orgo/prompt.py,sha256=ynblwXPTDp_aF1MbGBsY0PIEr9naklDaKFcfSE_EZ6E,19781
+orgo/api/__init__.py,sha256=9Tzb_OPJ5DH7Cg7OrHzpZZUT4ip05alpa9RLDYmnId8,113
+orgo/api/client.py,sha256=VGdlBCu2gAdDwMZ55n7kQS4R-CFXJjLByXPmRlMLoiY,9097
+orgo/utils/__init__.py,sha256=W4G_nwGBf_7jy0w_mfcrkllurYHSRU4B5cMTVYH_uCc,123
+orgo/utils/auth.py,sha256=tPLBJY-6gdBQWLUjUbwIwxHphC3KoRT_XgP3Iykw3Mw,509
+orgo-0.0.35.dist-info/METADATA,sha256=ig-dX2G_nd_pgcB-spU1DrSMgct5uc3xVhq3x1DRyIs,822
+orgo-0.0.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orgo-0.0.35.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
+orgo-0.0.35.dist-info/RECORD,,

orgo-0.0.32.dist-info/RECORD

@@ -1,12 +0,0 @@
-orgo/__init__.py,sha256=aw3BM7-Wy8jk-mvIWRG2gC4-nsc74s6ZFm1U21NyGeM,171
-orgo/computer.py,sha256=np8g67-ASCci3EmtQweCpOjDzeUMkXfAY9wve9s7tCc,14268
-orgo/project.py,sha256=uVDFa8iyn5OaHzTzjGQhxnF_nVzwkqkqUShiV3M0AWU,3150
-orgo/prompt.py,sha256=ynblwXPTDp_aF1MbGBsY0PIEr9naklDaKFcfSE_EZ6E,19781
-orgo/api/__init__.py,sha256=9Tzb_OPJ5DH7Cg7OrHzpZZUT4ip05alpa9RLDYmnId8,113
-orgo/api/client.py,sha256=apny7V3IYJTyDwn5utukzyECLWT65oo-1EmFRwHL--E,7544
-orgo/utils/__init__.py,sha256=W4G_nwGBf_7jy0w_mfcrkllurYHSRU4B5cMTVYH_uCc,123
-orgo/utils/auth.py,sha256=tPLBJY-6gdBQWLUjUbwIwxHphC3KoRT_XgP3Iykw3Mw,509
-orgo-0.0.32.dist-info/METADATA,sha256=w3RNXo5BW2YlXUgUb1TzkXaJ50RpkPd0Zd-vOllwx_A,822
-orgo-0.0.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orgo-0.0.32.dist-info/top_level.txt,sha256=q0rYtFji8GbYuhFW8A5Ab9e0j27761IKPhnL0E9xow4,5
-orgo-0.0.32.dist-info/RECORD,,