moru 0.1.0__py3-none-any.whl

moru/sandbox_sync/paginator.py

@@ -0,0 +1,69 @@
+import urllib.parse
+from typing import Optional, List
+
+from moru.api import handle_api_exception
+from moru.api.client.api.sandboxes import get_v2_sandboxes
+from moru.api.client.models.error import Error
+from moru.api.client.types import UNSET
+from moru.exceptions import SandboxException
+from moru.sandbox.sandbox_api import SandboxPaginatorBase, SandboxInfo
+from moru.api.client_sync import get_api_client
+
+
+class SandboxPaginator(SandboxPaginatorBase):
+    """
+    Paginator for listing sandboxes.
+
+    Example:
+    ```python
+    paginator = Sandbox.list()
+
+    while paginator.has_next:
+        sandboxes = paginator.next_items()
+        print(sandboxes)
+    ```
+    """
+
+    def next_items(self) -> List[SandboxInfo]:
+        """
+        Returns the next page of sandboxes.
+
+        Call this method only if `has_next` is `True`, otherwise it will raise an exception.
+
+        :returns: List of sandboxes
+        """
+        if not self.has_next:
+            raise Exception("No more items to fetch")
+
+        # Convert filters to the format expected by the API
+        metadata: Optional[str] = None
+        if self.query and self.query.metadata:
+            quoted_metadata = {
+                urllib.parse.quote(k): urllib.parse.quote(v)
+                for k, v in self.query.metadata.items()
+            }
+            metadata = urllib.parse.urlencode(quoted_metadata)
+
+        api_client = get_api_client(self._config)
+        res = get_v2_sandboxes.sync_detailed(
+            client=api_client,
+            metadata=metadata if metadata else UNSET,
+            state=self.query.state if self.query and self.query.state else UNSET,
+            limit=self.limit if self.limit else UNSET,
+            next_token=self._next_token if self._next_token else UNSET,
+        )
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        self._next_token = res.headers.get("x-next-token")
+        self._has_next = bool(self._next_token)
+
+        if res.parsed is None:
+            return []
+
+        # Check if res.parse is Error
+        if isinstance(res.parsed, Error):
+            raise SandboxException(f"{res.parsed.message}: Request failed")
+
+        return [SandboxInfo._from_listed_sandbox(sandbox) for sandbox in res.parsed]

moru/sandbox_sync/sandbox_api.py

@@ -0,0 +1,308 @@
+import datetime
+from typing import Dict, List, Optional
+
+from packaging.version import Version
+from typing_extensions import Unpack
+
+from moru.api import SandboxCreateResponse, handle_api_exception
+from moru.api.client.api.sandboxes import (
+    delete_sandboxes_sandbox_id,
+    get_sandboxes_sandbox_id,
+    get_sandboxes_sandbox_id_metrics,
+    post_sandboxes,
+    post_sandboxes_sandbox_id_connect,
+    post_sandboxes_sandbox_id_pause,
+    post_sandboxes_sandbox_id_timeout,
+)
+from moru.api.client.models import (
+    ConnectSandbox,
+    Error,
+    NewSandbox,
+    PostSandboxesSandboxIDTimeoutBody,
+    Sandbox,
+    SandboxNetworkConfig,
+)
+from moru.api.client.types import UNSET
+from moru.connection_config import ApiParams, ConnectionConfig
+from moru.exceptions import NotFoundException, SandboxException, TemplateException
+from moru.sandbox.main import SandboxBase
+from moru.sandbox.sandbox_api import (
+    McpServer,
+    SandboxInfo,
+    SandboxMetrics,
+    SandboxNetworkOpts,
+    SandboxQuery,
+)
+from moru.sandbox_sync.paginator import SandboxPaginator, get_api_client
+
+
+class SandboxApi(SandboxBase):
+    @staticmethod
+    def list(
+        query: Optional[SandboxQuery] = None,
+        limit: Optional[int] = None,
+        next_token: Optional[str] = None,
+        **opts: Unpack[ApiParams],
+    ) -> SandboxPaginator:
+        """
+        List all running sandboxes.
+
+        :param query: Filter the list of sandboxes by metadata or state, e.g. `SandboxListQuery(metadata={"key": "value"})` or `SandboxListQuery(state=[SandboxState.RUNNING])`
+        :param limit: Maximum number of sandboxes to return per page
+        :param next_token: Token for pagination
+
+        :return: List of running sandboxes
+        """
+        return SandboxPaginator(
+            query=query,
+            limit=limit,
+            next_token=next_token,
+            **opts,
+        )
+
+    @classmethod
+    def _cls_get_info(
+        cls,
+        sandbox_id: str,
+        **opts: Unpack[ApiParams],
+    ) -> SandboxInfo:
+        """
+        Get the sandbox info.
+        :param sandbox_id: Sandbox ID
+
+        :return: Sandbox info
+        """
+        config = ConnectionConfig(**opts)
+
+        api_client = get_api_client(config)
+        res = get_sandboxes_sandbox_id.sync_detailed(
+            sandbox_id,
+            client=api_client,
+        )
+
+        if res.status_code == 404:
+            raise NotFoundException(f"Sandbox {sandbox_id} not found")
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        if res.parsed is None:
+            raise SandboxException("Body of the request is None")
+
+        if isinstance(res.parsed, Error):
+            raise SandboxException(f"{res.parsed.message}: Request failed")
+
+        return SandboxInfo._from_sandbox_detail(res.parsed)
+
+    @classmethod
+    def _cls_kill(
+        cls,
+        sandbox_id: str,
+        **opts: Unpack[ApiParams],
+    ) -> bool:
+        config = ConnectionConfig(**opts)
+
+        if config.debug:
+            # Skip killing the sandbox in debug mode
+            return True
+
+        api_client = get_api_client(config)
+        res = delete_sandboxes_sandbox_id.sync_detailed(
+            sandbox_id,
+            client=api_client,
+        )
+
+        if res.status_code == 404:
+            return False
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        return True
+
+    @classmethod
+    def _cls_set_timeout(
+        cls,
+        sandbox_id: str,
+        timeout: int,
+        **opts: Unpack[ApiParams],
+    ) -> None:
+        config = ConnectionConfig(**opts)
+
+        if config.debug:
+            # Skip setting timeout in debug mode
+            return
+
+        api_client = get_api_client(config)
+        res = post_sandboxes_sandbox_id_timeout.sync_detailed(
+            sandbox_id,
+            client=api_client,
+            body=PostSandboxesSandboxIDTimeoutBody(timeout=timeout),
+        )
+
+        if res.status_code == 404:
+            raise NotFoundException(f"Sandbox {sandbox_id} not found")
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+    @classmethod
+    def _create_sandbox(
+        cls,
+        template: str,
+        timeout: int,
+        auto_pause: bool,
+        allow_internet_access: bool,
+        metadata: Optional[Dict[str, str]],
+        env_vars: Optional[Dict[str, str]],
+        secure: bool,
+        mcp: Optional[McpServer] = None,
+        network: Optional[SandboxNetworkOpts] = None,
+        **opts: Unpack[ApiParams],
+    ) -> SandboxCreateResponse:
+        config = ConnectionConfig(**opts)
+
+        api_client = get_api_client(config)
+        res = post_sandboxes.sync_detailed(
+            body=NewSandbox(
+                template_id=template,
+                auto_pause=auto_pause,
+                metadata=metadata or {},
+                timeout=timeout,
+                env_vars=env_vars or {},
+                mcp=mcp or UNSET,
+                secure=secure,
+                allow_internet_access=allow_internet_access,
+                network=SandboxNetworkConfig(**network) if network else UNSET,
+            ),
+            client=api_client,
+        )
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        if res.parsed is None:
+            raise Exception("Body of the request is None")
+
+        if isinstance(res.parsed, Error):
+            raise SandboxException(f"{res.parsed.message}: Request failed")
+
+        if Version(res.parsed.envd_version) < Version("0.1.0"):
+            SandboxApi._cls_kill(res.parsed.sandbox_id)
+            raise TemplateException(
+                "You need to update the template to use the new SDK. "
+                "You can do this by running `moru template build` in the directory with the template."
+            )
+
+        return SandboxCreateResponse(
+            sandbox_id=res.parsed.sandbox_id,
+            sandbox_domain=res.parsed.domain,
+            envd_version=res.parsed.envd_version,
+            envd_access_token=res.parsed.envd_access_token,
+            traffic_access_token=res.parsed.traffic_access_token,
+        )
+
+    @classmethod
+    def _cls_get_metrics(
+        cls,
+        sandbox_id: str,
+        start: Optional[datetime.datetime] = None,
+        end: Optional[datetime.datetime] = None,
+        **opts: Unpack[ApiParams],
+    ) -> List[SandboxMetrics]:
+        config = ConnectionConfig(**opts)
+
+        if config.debug:
+            # Skip getting the metrics in debug mode
+            return []
+
+        api_client = get_api_client(config)
+        res = get_sandboxes_sandbox_id_metrics.sync_detailed(
+            sandbox_id,
+            start=int(start.timestamp() * 1000) if start else None,
+            end=int(end.timestamp() * 1000) if end else None,
+            client=api_client,
+        )
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        if res.parsed is None:
+            return []
+
+        if isinstance(res.parsed, Error):
+            raise SandboxException(f"{res.parsed.message}: Request failed")
+
+        # Convert to typed SandboxMetrics objects
+        return [
+            SandboxMetrics(
+                cpu_count=metric.cpu_count,
+                cpu_used_pct=metric.cpu_used_pct,
+                disk_total=metric.disk_total,
+                disk_used=metric.disk_used,
+                mem_total=metric.mem_total,
+                mem_used=metric.mem_used,
+                timestamp=metric.timestamp,
+            )
+            for metric in res.parsed
+        ]
+
+    @classmethod
+    def _cls_connect(
+        cls,
+        sandbox_id: str,
+        timeout: Optional[int] = None,
+        **opts: Unpack[ApiParams],
+    ) -> Sandbox:
+        timeout = timeout or SandboxBase.default_sandbox_timeout
+
+        config = ConnectionConfig(**opts)
+
+        api_client = get_api_client(
+            config,
+            headers={
+                "Moru-Sandbox-Id": sandbox_id,
+                "Moru-Sandbox-Port": str(config.envd_port),
+            },
+        )
+        res = post_sandboxes_sandbox_id_connect.sync_detailed(
+            sandbox_id,
+            client=api_client,
+            body=ConnectSandbox(timeout=timeout),
+        )
+
+        if res.status_code == 404:
+            raise NotFoundException(f"Paused sandbox {sandbox_id} not found")
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        if isinstance(res.parsed, Error):
+            raise SandboxException(f"{res.parsed.message}: Request failed")
+
+        return res.parsed
+
+    @classmethod
+    def _cls_pause(
+        cls,
+        sandbox_id: str,
+        **opts: Unpack[ApiParams],
+    ) -> str:
+        config = ConnectionConfig(**opts)
+
+        api_client = get_api_client(config)
+        res = post_sandboxes_sandbox_id_pause.sync_detailed(
+            sandbox_id,
+            client=api_client,
+        )
+
+        if res.status_code == 404:
+            raise NotFoundException(f"Sandbox {sandbox_id} not found")
+
+        if res.status_code == 409:
+            return sandbox_id
+
+        if res.status_code >= 300:
+            raise handle_api_exception(res)
+
+        return sandbox_id

moru/template/consts.py

@@ -0,0 +1,30 @@
+"""
+Special step name for the finalization phase of template building.
+This is the last step that runs after all user-defined instructions.
+"""
+
+FINALIZE_STEP_NAME = "finalize"
+
+"""
+Special step name for the base image phase of template building.
+This is the first step that sets up the base image.
+"""
+BASE_STEP_NAME = "base"
+
+"""
+Stack trace depth for capturing caller information.
+
+Depth levels:
+1. TemplateClass
+2. Caller method (e.g., copy(), from_image(), etc.)
+
+This depth is used to determine the original caller's location
+for stack traces.
+"""
+STACK_TRACE_DEPTH = 2
+
+"""
+Default setting for whether to resolve symbolic links when copying files.
+When False, symlinks are copied as symlinks rather than following them.
+"""
+RESOLVE_SYMLINKS = False

moru/template/dockerfile_parser.py

@@ -0,0 +1,275 @@
+import json
+import os
+import re
+import tempfile
+from typing import Dict, List, Optional, Protocol, Union, Literal
+
+from dockerfile_parse import DockerfileParser
+from moru.template.types import CopyItem
+
+
+class DockerfFileFinalParserInterface(Protocol):
+    """Protocol defining the final interface for Dockerfile parsing callbacks."""
+
+
+class DockerfileParserInterface(Protocol):
+    """Protocol defining the interface for Dockerfile parsing callbacks."""
+
+    def run_cmd(
+        self, command: Union[str, List[str]], user: Optional[str] = None
+    ) -> "DockerfileParserInterface":
+        """Handle RUN instruction."""
+        ...
+
+    def copy(
+        self,
+        src: Union[str, List[CopyItem]],
+        dest: Optional[str] = None,
+        force_upload: Optional[Literal[True]] = None,
+        resolve_symlinks: Optional[bool] = None,
+        user: Optional[str] = None,
+        mode: Optional[int] = None,
+    ) -> "DockerfileParserInterface":
+        """Handle COPY instruction."""
+        ...
+
+    def set_workdir(self, workdir: str) -> "DockerfileParserInterface":
+        """Handle WORKDIR instruction."""
+        ...
+
+    def set_user(self, user: str) -> "DockerfileParserInterface":
+        """Handle USER instruction."""
+        ...
+
+    def set_envs(self, envs: Dict[str, str]) -> "DockerfileParserInterface":
+        """Handle ENV instruction."""
+        ...
+
+    def set_start_cmd(
+        self, start_cmd: str, ready_cmd: str
+    ) -> "DockerfFileFinalParserInterface":
+        """Handle CMD/ENTRYPOINT instruction."""
+        ...
+
+
+def parse_dockerfile(
+    dockerfile_content_or_path: str, template_builder: DockerfileParserInterface
+) -> str:
+    """
+    Parse a Dockerfile and convert it to Template SDK format.
+
+    :param dockerfile_content_or_path: Either the Dockerfile content as a string, or a path to a Dockerfile file
+    :param template_builder: Interface providing template builder methods
+
+    :return: The base image from the Dockerfile
+
+    :raises ValueError: If the Dockerfile is invalid or unsupported
+    """
+    # Check if input is a file path that exists
+    if os.path.isfile(dockerfile_content_or_path):
+        # Read the file content
+        with open(dockerfile_content_or_path, "r", encoding="utf-8") as f:
+            dockerfile_content = f.read()
+    else:
+        # Treat as content directly
+        dockerfile_content = dockerfile_content_or_path
+
+    # Use a temporary directory to avoid creating files in the current directory
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Create a temporary Dockerfile
+        dockerfile_path = os.path.join(temp_dir, "Dockerfile")
+        with open(dockerfile_path, "w") as f:
+            f.write(dockerfile_content)
+
+        dfp = DockerfileParser(path=temp_dir)
+
+        # Check for multi-stage builds
+        from_instructions = [
+            instruction
+            for instruction in dfp.structure
+            if instruction["instruction"] == "FROM"
+        ]
+
+        if len(from_instructions) > 1:
+            raise ValueError("Multi-stage Dockerfiles are not supported")
+
+        if len(from_instructions) == 0:
+            raise ValueError("Dockerfile must contain a FROM instruction")
+
+        # Set the base image from the first FROM instruction
+        base_image = from_instructions[0]["value"]
+        # Remove AS alias if present (e.g., "node:18 AS builder" -> "node:18")
+        if " as " in base_image.lower():
+            base_image = base_image.split(" as ")[0].strip()
+
+        user_changed = False
+        workdir_changed = False
+
+        # Set the user and workdir to the Docker defaults
+        template_builder.set_user("root")
+        template_builder.set_workdir("/")
+
+        # Process all other instructions
+        for instruction_data in dfp.structure:
+            instruction = instruction_data["instruction"]
+            value = instruction_data["value"]
+
+            if instruction == "FROM":
+                # Already handled above
+                continue
+            elif instruction == "RUN":
+                _handle_run_instruction(value, template_builder)
+            elif instruction in ["COPY", "ADD"]:
+                _handle_copy_instruction(value, template_builder)
+            elif instruction == "WORKDIR":
+                _handle_workdir_instruction(value, template_builder)
+                workdir_changed = True
+            elif instruction == "USER":
+                _handle_user_instruction(value, template_builder)
+                user_changed = True
+            elif instruction in ["ENV", "ARG"]:
+                _handle_env_instruction(value, instruction, template_builder)
+            elif instruction in ["CMD", "ENTRYPOINT"]:
+                _handle_cmd_entrypoint_instruction(value, template_builder)
+            else:
+                print(f"Unsupported instruction: {instruction}")
+                continue
+
+    # Set the user and workdir to the Moru defaults
+    if not user_changed:
+        template_builder.set_user("user")
+    if not workdir_changed:
+        template_builder.set_workdir("/home/user")
+
+    return base_image
+
+
+def _handle_run_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle RUN instruction"""
+    if not value.strip():
+        return
+    # Remove line continuations and normalize whitespace
+    command = re.sub(r"\\\s*\n\s*", " ", value).strip()
+    template_builder.run_cmd(command)
+
+
+def _handle_copy_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle COPY/ADD instruction"""
+    if not value.strip():
+        return
+    # Parse source and destination from COPY/ADD command
+    # Handle both quoted and unquoted paths
+    parts = []
+    current_part = ""
+    in_quotes = False
+    quote_char = None
+
+    i = 0
+    while i < len(value):
+        char = value[i]
+        if char in ['"', "'"] and (i == 0 or value[i - 1] != "\\"):
+            if not in_quotes:
+                in_quotes = True
+                quote_char = char
+            elif char == quote_char:
+                in_quotes = False
+                quote_char = None
+            else:
+                current_part += char
+        elif char == " " and not in_quotes:
+            if current_part:
+                parts.append(current_part)
+                current_part = ""
+        else:
+            current_part += char
+        i += 1
+
+    if current_part:
+        parts.append(current_part)
+
+    if len(parts) >= 2:
+        src = parts[0]
+        dest = parts[-1]  # Last part is destination
+        template_builder.copy(src, dest)
+
+
+def _handle_workdir_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle WORKDIR instruction"""
+    if not value.strip():
+        return
+    workdir = value.strip()
+    template_builder.set_workdir(workdir)
+
+
+def _handle_user_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle USER instruction"""
+    if not value.strip():
+        return
+    user = value.strip()
+    template_builder.set_user(user)
+
+
+def _handle_env_instruction(
+    value: str, instruction_type: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle ENV/ARG instruction"""
+    if not value.strip():
+        return
+
+    # Parse environment variables from the value
+    # Handle both "KEY=value" and "KEY value" formats
+    env_vars = {}
+
+    # First try to split on = for KEY=value format
+    if "=" in value:
+        # Handle multiple KEY=value pairs on one line
+        pairs = re.findall(r"(\w+)=([^\s]*(?:\s+(?!\w+=)[^\s]*)*)", value)
+        for key, val in pairs:
+            env_vars[key] = val.strip("\"'")
+    else:
+        # Handle "KEY value" format
+        parts = value.split(None, 1)
+        if len(parts) == 2:
+            key, val = parts
+            env_vars[key] = val.strip("\"'")
+        elif len(parts) == 1 and instruction_type == "ARG":
+            # ARG without default value
+            key = parts[0]
+            env_vars[key] = ""
+
+    # Add each environment variable
+    if env_vars:
+        template_builder.set_envs(env_vars)
+
+
+def _handle_cmd_entrypoint_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle CMD/ENTRYPOINT instruction - convert to set_start_cmd with 20s timeout"""
+    if not value.strip():
+        return
+    command = value.strip()
+
+    # Try to parse as JSON (for array format like CMD ["sleep", "infinity"])
+    try:
+        parsed_command = json.loads(command)
+        if isinstance(parsed_command, list):
+            command = " ".join(str(item) for item in parsed_command)
+    except Exception:
+        pass
+
+    # Import wait_for_timeout locally to avoid circular dependency
+    def wait_for_timeout(timeout: int) -> str:
+        # convert to seconds, but ensure minimum of 1 second
+        seconds = max(1, timeout // 1000)
+        return f"sleep {seconds}"
+
+    template_builder.set_start_cmd(command, wait_for_timeout(20_000))