orgo 0.0.39__tar.gz → 0.0.41__tar.gz

{orgo-0.0.39 → orgo-0.0.41}/PKG-INFO

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

{orgo-0.0.39 → orgo-0.0.41}/pyproject.toml

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

orgo-0.0.41/src/orgo/__init__.py

@@ -0,0 +1,12 @@
+# src/orgo/__init__.py
+"""Orgo SDK: Desktop infrastructure for AI agents"""
+
+from .project import Project
+from .computer import Computer
+from .template import Template
+
+# Aliases
+Workspace = Project  # Workspace is an alias for Project
+Forge = Template     # Forge is deprecated, use Template instead
+
+__all__ = ["Project", "Workspace", "Computer", "Template", "Forge"]

{orgo-0.0.39 → orgo-0.0.41}/src/orgo/api/client.py

@@ -78,12 +78,12 @@ class ApiClient:
         return self._request("DELETE", f"projects/{project_id}")
     
     # Computer methods
-    def create_computer(self, project_id: str, computer_name: str, 
-                       os: str = "linux", ram: int = 2, cpu: int = 2, 
+    def create_computer(self, project_id: str, computer_name: str,
+                       os: str = "linux", ram: int = 2, cpu: int = 2,
                        gpu: str = "none", image: Optional[str] = None) -> Dict[str, Any]:
-        """Create a new computer within a project"""
+        """Create a new computer within a workspace/project"""
         data = {
-            "project_id": project_id,
+            "workspace_id": project_id,  # API accepts both workspace_id and project_id
             "name": computer_name,
             "os": os,
             "ram": ram,
@@ -92,7 +92,7 @@ class ApiClient:
         }
         if image:
             data["image"] = image
-            
+
         return self._request("POST", "computers", data)
     
     def list_computers(self, project_id: str) -> List[Dict[str, Any]]:
@@ -211,8 +211,8 @@ class ApiClient:
             "name": name
         })
 
-    def update_build(self, build_id: str, status: str, 
-                     error_message: Optional[str] = None, 
+    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 = {
@@ -222,6 +222,6 @@ class ApiClient:
         if error_message:
             data["errorMessage"] = error_message
         if build_log:
-            data["buildLog"] = build_log
-            
+            data["logs"] = build_log
+
         return self._request("POST", "builds/update", data)

{orgo-0.0.39 → orgo-0.0.41}/src/orgo/computer.py

@@ -66,24 +66,27 @@ class Computer:
         computer.prompt("Open Firefox", provider="anthropic")
     """
     
-    def __init__(self, 
+    def __init__(self,
                  project: Optional[Union[str, 'Project']] = None,
+                 workspace: Optional[Union[str, 'Project']] = None,  # Alias for project
                  name: Optional[str] = None,
                  computer_id: Optional[str] = None,
-                 api_key: Optional[str] = None, 
+                 api_key: Optional[str] = None,
                  base_api_url: Optional[str] = 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,
-                 image: Optional[Union[str, Any]] = None,
+                 template: Optional[Union[str, Any]] = None,
+                 image: Optional[Union[str, Any]] = None,  # Deprecated, use template
                  verbose: bool = True):
         """
         Initialize an Orgo virtual computer.
-        
+
         Args:
-            project: Project name or Project instance (creates if doesn't exist)
+            project: Project/workspace name or instance (creates if doesn't exist)
+            workspace: Alias for project (preferred name going forward)
             name: Computer name (auto-generated if not provided)
             computer_id: Connect to existing computer by ID
             api_key: Orgo API key (defaults to ORGO_API_KEY env var)
@@ -92,9 +95,13 @@ class Computer:
             cpu: CPU cores (1, 2, 4, 8, 16)
             os: "linux" or "windows"
             gpu: "none", "a10", "l40s", "a100-40gb", "a100-80gb"
-            image: Custom image reference or Forge object
+            template: Template name or Template object to use
+            image: Deprecated, use template instead
             verbose: Show console output (default: True)
         """
+        # workspace is an alias for project
+        if workspace is not None and project is None:
+            project = workspace
         self.api_key = api_key or operating_system.environ.get("ORGO_API_KEY")
         self.base_api_url = base_api_url
         self.api = ApiClient(self.api_key, self.base_api_url)
@@ -102,17 +109,32 @@ class Computer:
         
         if ram is None and memory is not None:
             ram = memory
-        
+
         self.os = os or "linux"
         self.ram = ram or 2
         self.cpu = cpu or 2
         self.gpu = gpu or "none"
-        self.image = image
-        
-        if hasattr(self.image, 'build') and callable(self.image.build):
+
+        # Handle template parameter (preferred) or image (deprecated)
+        self.template = template or image
+
+        # If template is a Template object, get its image_ref or build it
+        if hasattr(self.template, 'image_ref'):
+            if self.template.image_ref:
+                self.template = self.template.image_ref
+            elif hasattr(self.template, 'build') and callable(self.template.build):
+                if self.verbose:
+                    _print_info("Building template...")
+                self.template = self.template.build()
+            elif hasattr(self.template, 'name'):
+                # Template object with name but not built - use name for lookup
+                self.template = self.template.name
+
+        # Legacy: handle old Forge objects that might not have image_ref
+        elif hasattr(self.template, 'build') and callable(self.template.build):
             if self.verbose:
-                _print_info("Building image from Forge object...")
-            self.image = self.image.build()
+                _print_info("Building image...")
+            self.template = self.template.build()
         
         if computer_id:
             self.computer_id = computer_id
@@ -213,20 +235,23 @@ class Computer:
         if self.gpu not in ["none", "a10", "l40s", "a100-40gb", "a100-80gb"]:
             raise ValueError("gpu must be: 'none', 'a10', 'l40s', 'a100-40gb', or 'a100-80gb'")
         
-        # Resolve image if needed
-        image_ref = self.image
+        # Resolve template to image reference if needed
+        image_ref = self.template
         if image_ref and isinstance(image_ref, str) and not image_ref.startswith("registry.fly.io"):
+            # Template name provided - look up the latest build
             try:
                 project_info = self.api.get_project(project_id)
-                org_id = project_info.get("org_id", "orgo")
+                org_id = project_info.get("user_id", "orgo")
                 response = self.api.get_latest_build(org_id, project_id, image_ref)
                 if response and response.get("build"):
                     resolved = response.get("build", {}).get("imageRef")
                     if resolved:
                         image_ref = resolved
+                        if self.verbose:
+                            _print_info(f"Using template '{self.template}'")
             except Exception as e:
                 if self.verbose:
-                    logger.warning(f"Failed to resolve image: {e}")
+                    logger.warning(f"Template '{image_ref}' not found, using default image")
         
         # Create the computer
         try:

orgo-0.0.41/src/orgo/template.py

@@ -0,0 +1,347 @@
+"""
+Orgo Template - Pre-configure computer environments.
+
+Usage:
+    from orgo import Template, Computer
+
+    # Create a template with pre-installed software
+    template = Template("python-ml")
+    template.run("pip install numpy pandas scikit-learn")
+    template.build()
+
+    # Launch computers from the template
+    computer = Computer(template="python-ml")
+"""
+
+import os
+import subprocess
+import logging
+from typing import Optional, List
+
+from .api.client import ApiClient
+
+logger = logging.getLogger(__name__)
+
+
+def _print_info(message: str):
+    print(f"-> {message}")
+
+
+def _print_success(message: str):
+    print(f"[ok] {message}")
+
+
+def _print_error(message: str):
+    print(f"[error] {message}")
+
+
+class Template:
+    """
+    Create reusable computer templates with pre-installed software.
+
+    Templates let you define a base environment once and launch multiple
+    computers from it. This is useful for:
+    - Pre-installing dependencies (Python packages, apt packages, etc.)
+    - Cloning repositories
+    - Setting up configuration files
+
+    Examples:
+        # Create and build a template
+        template = Template("data-science")
+        template.run("apt-get update && apt-get install -y python3-pip")
+        template.run("pip install numpy pandas matplotlib jupyter")
+        template.build()
+
+        # Launch a computer from the template
+        computer = Computer(template="data-science")
+
+        # Or pass the template object directly
+        computer = Computer(template=template)
+    """
+
+    def __init__(self,
+                 name: str,
+                 workspace: Optional[str] = None,
+                 api_key: Optional[str] = None,
+                 base_api_url: Optional[str] = None,
+                 verbose: bool = True):
+        """
+        Initialize a Template.
+
+        Args:
+            name: Template name (used to reference it later)
+            workspace: Workspace to store the template in (auto-created if needed)
+            api_key: Orgo API key (defaults to ORGO_API_KEY env var)
+            base_api_url: Custom API URL
+            verbose: Show console output (default: True)
+        """
+        self.name = name
+        self.verbose = verbose
+        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)
+
+        # Resolve workspace
+        workspace_name = workspace or "templates"
+        self._resolve_workspace(workspace_name)
+
+        # Build steps (starts with Orgo base image)
+        self._steps: List[str] = ["FROM registry.fly.io/orgo-image-repo:latest"]
+        self._image_ref: Optional[str] = None
+
+        if self.verbose:
+            _print_info(f"Template '{name}' initialized")
+
+    def _resolve_workspace(self, workspace_name: str):
+        """Find or create workspace for templates"""
+        try:
+            workspace = self.api.get_project_by_name(workspace_name)
+            self._workspace_id = workspace["id"]
+            self._org_id = workspace.get("user_id", "orgo")
+        except Exception:
+            if self.verbose:
+                _print_info(f"Creating workspace '{workspace_name}'...")
+            workspace = self.api.create_project(workspace_name)
+            self._workspace_id = workspace["id"]
+            self._org_id = workspace.get("user_id", "orgo")
+
+    # =========================================================================
+    # Build Steps (Chainable)
+    # =========================================================================
+
+    def run(self, command: str) -> 'Template':
+        """
+        Run a command during build (like apt-get, pip install, etc.)
+
+        Args:
+            command: Shell command to run
+
+        Returns:
+            Self for chaining
+
+        Example:
+            template.run("apt-get update")
+            template.run("pip install requests")
+        """
+        self._steps.append(f"RUN {command}")
+        return self
+
+    def copy(self, src: str, dest: str) -> 'Template':
+        """
+        Copy local files into the template.
+
+        Args:
+            src: Local file or directory path
+            dest: Destination path in the template
+
+        Returns:
+            Self for chaining
+
+        Example:
+            template.copy("./config.json", "/app/config.json")
+            template.copy("./scripts", "/app/scripts")
+        """
+        self._steps.append(f"COPY {src} {dest}")
+        return self
+
+    def env(self, key: str, value: str) -> 'Template':
+        """
+        Set an environment variable.
+
+        Args:
+            key: Environment variable name
+            value: Environment variable value
+
+        Returns:
+            Self for chaining
+
+        Example:
+            template.env("PYTHONPATH", "/app")
+            template.env("DEBUG", "true")
+        """
+        self._steps.append(f"ENV {key}={value}")
+        return self
+
+    def workdir(self, path: str) -> 'Template':
+        """
+        Set the working directory.
+
+        Args:
+            path: Directory path
+
+        Returns:
+            Self for chaining
+
+        Example:
+            template.workdir("/app")
+        """
+        self._steps.append(f"WORKDIR {path}")
+        return self
+
+    def clone(self, repo_url: str, dest: str = "/repo") -> 'Template':
+        """
+        Clone a git repository.
+
+        Args:
+            repo_url: Git repository URL
+            dest: Destination directory (default: /repo)
+
+        Returns:
+            Self for chaining
+
+        Example:
+            template.clone("https://github.com/user/repo.git")
+            template.clone("https://github.com/user/repo.git", "/app")
+        """
+        self._steps.append(f"RUN git clone {repo_url} {dest}")
+        return self
+
+    # =========================================================================
+    # Build
+    # =========================================================================
+
+    def build(self, context: str = ".") -> str:
+        """
+        Build and publish the template.
+
+        This builds a Docker image with your configuration and pushes it
+        to Orgo's registry. After building, you can launch computers from
+        this template using Computer(template="name").
+
+        Args:
+            context: Build context directory (default: current directory)
+
+        Returns:
+            Image reference string
+
+        Example:
+            template.run("pip install pandas")
+            image_ref = template.build()
+            print(f"Built: {image_ref}")
+        """
+        if len(self._steps) <= 1:
+            raise ValueError("No build steps defined. Use .run(), .copy(), etc. first.")
+
+        if self.verbose:
+            _print_info(f"Building template '{self.name}'...")
+
+        # Register build with API
+        try:
+            build_info = self.api.create_build(self._org_id, self._workspace_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')
+
+            if not build_id or not image_ref:
+                raise ValueError("Failed to register build")
+
+            if self.verbose:
+                _print_info(f"Build ID: {build_id}")
+                _print_info(f"Image: {image_ref}")
+
+        except Exception as e:
+            _print_error(f"Failed to register build: {e}")
+            raise
+
+        # Generate Dockerfile
+        dockerfile_path = f"Dockerfile.{tag}"
+        logs = []
+
+        try:
+            with open(dockerfile_path, "w") as f:
+                f.write("\n".join(self._steps))
+
+            # Update status
+            self.api.update_build(build_id, "building")
+
+            # Setup remote builder
+            builder_name = "orgo-remote"
+            remote_url = "tcp://orgoforge.fly.dev:1234"
+
+            try:
+                subprocess.run(
+                    ["docker", "buildx", "inspect", builder_name],
+                    check=True,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+            except subprocess.CalledProcessError:
+                if self.verbose:
+                    _print_info("Setting up build environment...")
+                subprocess.run([
+                    "docker", "buildx", "create",
+                    "--name", builder_name,
+                    "--driver", "remote",
+                    remote_url,
+                    "--use"
+                ], check=True)
+                subprocess.run(["docker", "buildx", "inspect", "--bootstrap"], check=True)
+
+            # Build and push
+            cmd = [
+                "docker", "buildx", "build",
+                "--builder", builder_name,
+                "-t", image_ref,
+                "-f", dockerfile_path,
+                context,
+                "--push"
+            ]
+
+            if self.verbose:
+                _print_info("Building image...")
+
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1
+            )
+
+            while True:
+                line = process.stdout.readline()
+                if not line and process.poll() is not None:
+                    break
+                if line:
+                    if self.verbose:
+                        print(line, end="")
+                    logs.append(line)
+
+            if process.returncode != 0:
+                raise Exception(f"Build failed with exit code {process.returncode}")
+
+            # Success
+            self.api.update_build(build_id, "completed", build_log="".join(logs))
+            self._image_ref = image_ref
+
+            if self.verbose:
+                _print_success(f"Template '{self.name}' built successfully!")
+
+            return image_ref
+
+        except Exception as e:
+            _print_error(f"Build failed: {e}")
+            try:
+                self.api.update_build(build_id, "failed", error_message=str(e), build_log="".join(logs))
+            except:
+                pass
+            raise
+
+        finally:
+            if os.path.exists(dockerfile_path):
+                os.remove(dockerfile_path)
+
+    # =========================================================================
+    # Properties
+    # =========================================================================
+
+    @property
+    def image_ref(self) -> Optional[str]:
+        """Get the built image reference (None if not built yet)."""
+        return self._image_ref
+
+    def __repr__(self):
+        status = "built" if self._image_ref else "not built"
+        return f"Template(name='{self.name}', status='{status}')"

{orgo-0.0.39 → orgo-0.0.41}/src/orgo.egg-info/PKG-INFO

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

{orgo-0.0.39 → orgo-0.0.41}/src/orgo.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/orgo/computer.py
 src/orgo/forge.py
 src/orgo/project.py
 src/orgo/prompt.py
+src/orgo/template.py
 src/orgo.egg-info/PKG-INFO
 src/orgo.egg-info/SOURCES.txt
 src/orgo.egg-info/dependency_links.txt

orgo-0.0.39/src/orgo/__init__.py

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