orgo 0.0.31__tar.gz → 0.0.34__tar.gz

{orgo-0.0.31 → orgo-0.0.34}/PKG-INFO

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

{orgo-0.0.31 → orgo-0.0.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orgo"
-version = "0.0.31"
+version = "0.0.34"
 description = "Computers for AI agents"
 authors = [{name = "Orgo Team"}]
 license = {text = "MIT"}

{orgo-0.0.31 → orgo-0.0.34}/src/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-0.0.31 → orgo-0.0.34}/src/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-0.0.31 → orgo-0.0.34}/src/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,16 +40,21 @@ 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)
             
-            # Connect to existing computer in project
-            computer = Computer(project="manus")
+            # Connect to existing computer by ID
+            computer = Computer(computer_id="11c4fd46-e069-4c32-be65-f82d9f87b9b8")
         """
         self.api_key = api_key or operating_system.environ.get("ORGO_API_KEY")
         self.base_api_url = base_api_url
@@ -64,9 +70,20 @@ 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:
-            # Connect to existing computer by ID
-            self._connect_by_id(computer_id)
+
+            # Just store the computer ID, no API call needed
+            self.computer_id = computer_id
+            self.name = name
+            self.project_id = None
+            self.project_name = None
+            logger.info(f"Connected to computer ID: {self.computer_id}")
         elif project:
             # Work with specified project
             if isinstance(project, str):
@@ -86,17 +103,6 @@ class Computer:
             # 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_id = self._info.get("project_id")
-        self.name = self._info.get("name")
-        # Get project name
-        if self.project_id:
-            project = self.api.get_project(self.project_id)
-            self.project_name = project.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:
@@ -165,7 +171,6 @@ class Computer:
         """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_id: str, computer_name: Optional[str]):
@@ -185,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,
@@ -192,10 +219,10 @@ 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")
-        self._info = computer
         logger.info(f"Created new computer {self.name} (ID: {self.computer_id})")
     
     def status(self) -> Dict[str, Any]:
@@ -299,7 +326,7 @@ 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,
@@ -330,4 +357,6 @@ class Computer:
         )
     
     def __repr__(self):
-        return f"Computer(name='{self.name}', project='{self.project_name}', id='{self.computer_id}')"
+        project_str = f", project='{self.project_name}'" if hasattr(self, 'project_name') and self.project_name else ""
+        name_str = f"name='{self.name}'" if hasattr(self, 'name') and self.name else f"id='{self.computer_id}'"
+        return f"Computer({name_str}{project_str})"

orgo-0.0.34/src/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-0.0.31 → orgo-0.0.34}/src/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.31 → orgo-0.0.34}/src/orgo.egg-info/PKG-INFO

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

{orgo-0.0.31 → orgo-0.0.34}/src/orgo.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 src/orgo/__init__.py
 src/orgo/computer.py
+src/orgo/forge.py
 src/orgo/project.py
 src/orgo/prompt.py
 src/orgo.egg-info/PKG-INFO