friday-framework-sandbox 0.1.0a0__tar.gz

friday_framework_sandbox-0.1.0a0/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.pyc
+.env
+.venv/
+.idea/
+.vscode/
+dist/
+build/
+*.egg-info/
+chroma_db/
+.friday/
+/vector/
+/exports/
+tests/integration/memory/vector/*/
+tests/integration/memory/vector/backups/*/
+tests/integration/memory/vector/reorganization_logs/*
+*.gpickle
+keys.txt
+experiments/*/config/runtime.local.yaml
+experiments/*/artifacts/*
+!experiments/*/artifacts/.gitkeep
+scripts/source-friday-chat-example-env.sh
+/docs/reference/PyPI-Recovery-Codes-cichuck-2026-07-20T15_36_49.709334.txt

friday_framework_sandbox-0.1.0a0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: friday-framework-sandbox
+Version: 0.1.0a0
+Summary: Docker-based code execution sandbox for AI agents
+Author: Friday Team
+License-Expression: MIT
+Keywords: agents,ai,code-execution,docker,sandbox
+Requires-Python: >=3.10
+Requires-Dist: docker>=7.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'

friday_framework_sandbox-0.1.0a0/docker/Dockerfile.python

@@ -0,0 +1,45 @@
+# Friday Sandbox Python Image
+# Provides a secure, minimal Python environment for code execution
+#
+# Ref: docs/specs/sandbox_specifications.md - Section 9: Docker Image
+
+FROM python:3.11-slim-bookworm
+
+# Labels
+LABEL org.opencontainers.image.title="Friday Sandbox Python"
+LABEL org.opencontainers.image.description="Secure Python execution environment for AI agents"
+LABEL org.opencontainers.image.version="0.1.0"
+LABEL org.opencontainers.image.vendor="Friday Team"
+
+# Security: Create non-root user
+RUN groupadd -r sandbox && useradd -r -g sandbox sandbox
+
+# Install common Python packages for data processing and analysis
+RUN pip install --no-cache-dir \
+    # Data processing
+    numpy>=1.24.0 \
+    pandas>=2.0.0 \
+    # JSON/YAML handling
+    pyyaml>=6.0 \
+    # HTTP requests
+    requests>=2.28.0 \
+    httpx>=0.24.0 \
+    # Pydantic for structured returns
+    pydantic>=2.0.0 \
+    # Date handling
+    python-dateutil>=2.8.0 \
+    # Math
+    sympy>=1.12 \
+    && rm -rf /root/.cache/pip
+
+# Create workspace directory with correct permissions
+RUN mkdir -p /workspace && chown sandbox:sandbox /workspace
+
+# Set working directory
+WORKDIR /workspace
+
+# Switch to non-root user
+USER sandbox
+
+# Default command (will be overridden)
+CMD ["python", "--version"]

friday_framework_sandbox-0.1.0a0/docker/build.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Build the Friday Sandbox Python Docker image
+#
+# Usage:
+#   ./build.sh           # Build with default tag
+#   ./build.sh v1.0.0    # Build with specific version tag
+#
+# Ref: docs/specs/sandbox_specifications.md - Section 9: Docker Image
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+IMAGE_NAME="friday-sandbox-python"
+VERSION="${1:-latest}"
+
+echo "Building Friday Sandbox Python image..."
+echo "  Image: ${IMAGE_NAME}:${VERSION}"
+
+docker build \
+    -t "${IMAGE_NAME}:${VERSION}" \
+    -f "${SCRIPT_DIR}/Dockerfile.python" \
+    "${SCRIPT_DIR}"
+
+# Also tag as latest if version was specified
+if [ "${VERSION}" != "latest" ]; then
+    docker tag "${IMAGE_NAME}:${VERSION}" "${IMAGE_NAME}:latest"
+    echo "  Also tagged as: ${IMAGE_NAME}:latest"
+fi
+
+echo ""
+echo "Build complete!"
+echo ""
+echo "Test the image with:"
+echo "  docker run --rm ${IMAGE_NAME}:${VERSION} python -c 'print(\"Hello from Friday Sandbox!\")'"

friday_framework_sandbox-0.1.0a0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "friday-framework-sandbox"
+version = "0.1.0a0"
+description = "Docker-based code execution sandbox for AI agents"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Friday Team" }]
+keywords = ["ai", "agents", "sandbox", "docker", "code-execution"]
+
+dependencies = [
+    "docker>=7.0.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-mock>=3.10.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/friday_sandbox"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests_sandbox"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]

friday_framework_sandbox-0.1.0a0/src/friday_sandbox/__init__.py

@@ -0,0 +1,80 @@
+# mypy: ignore-errors
+"""
+Friday Sandbox - Docker-based code execution for AI agents.
+
+This package provides secure, isolated code execution environments
+for AI agents to run dynamically generated code safely.
+
+Ref: docs/reference/specs/sandbox_specifications.md
+"""
+
+from .config import DockerConfig, SandboxConfig, WorkspaceConfig
+from .models import (
+    ExecutionResult,
+    SandboxError,
+    SandboxExecutionError,
+    SandboxTimeoutError,
+    Workspace,
+    WorkspaceExpiredError,
+    WorkspaceNotFoundError,
+)
+from .protocols import SandboxProtocol
+from .workspace import WorkspaceManager
+
+
+# Lazy imports for sandbox implementations to avoid import errors
+# when Docker SDK is not installed
+def get_docker_sandbox():
+    """Get DockerSandbox class (requires docker SDK)."""
+    from .docker import DockerSandbox
+
+    return DockerSandbox
+
+
+def get_subprocess_sandbox():
+    """Get SubprocessSandbox class."""
+    from .subprocess import SubprocessSandbox
+
+    return SubprocessSandbox
+
+
+def get_mock_sandbox():
+    """Get MockSandbox class."""
+    from .mock import MockSandbox
+
+    return MockSandbox
+
+
+def get_mock_sandbox_builder():
+    """Get MockSandboxBuilder class."""
+    from .mock import MockSandboxBuilder
+
+    return MockSandboxBuilder
+
+
+__all__ = [
+    # Protocols
+    "SandboxProtocol",
+    # Models
+    "ExecutionResult",
+    "Workspace",
+    # Errors
+    "SandboxError",
+    "SandboxTimeoutError",
+    "SandboxExecutionError",
+    "WorkspaceNotFoundError",
+    "WorkspaceExpiredError",
+    # Config
+    "SandboxConfig",
+    "WorkspaceConfig",
+    "DockerConfig",
+    # Manager
+    "WorkspaceManager",
+    # Sandbox implementations (lazy loaded)
+    "get_docker_sandbox",
+    "get_subprocess_sandbox",
+    "get_mock_sandbox",
+    "get_mock_sandbox_builder",
+]
+
+__version__ = "0.1.0"

friday_framework_sandbox-0.1.0a0/src/friday_sandbox/config.py

@@ -0,0 +1,252 @@
+# mypy: ignore-errors
+"""
+Configuration models for sandbox and workspace management.
+
+Ref: docs/reference/specs/sandbox_specifications.md - Section 4: Configuration
+
+Configuration follows a layered approach:
+1. Package defaults (defined here)
+2. Environment variables (FRIDAY_SANDBOX_*)
+3. Agent profile settings
+4. Per-execution overrides
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class WorkspaceConfig(BaseModel):
+    """
+    Configuration for workspace lifecycle management.
+
+    Controls TTL, cleanup behavior, and resource limits for workspaces.
+    """
+
+    # TTL Configuration
+    ttl_seconds: int = Field(
+        default=3600,
+        ge=60,
+        le=86400,
+        description="Default workspace TTL in seconds (1 hour default)",
+    )
+    ttl_soft_limit_seconds: int = Field(
+        default=3600,
+        ge=60,
+        description="Soft limit before warning (1 hour)",
+    )
+    ttl_hard_limit_seconds: int = Field(
+        default=86400,
+        ge=3600,
+        description="Hard limit - force cleanup (24 hours)",
+    )
+
+    # Cleanup Configuration
+    cleanup_interval_seconds: int = Field(
+        default=300,
+        ge=60,
+        description="Interval between cleanup sweeps (5 minutes)",
+    )
+    preserve_on_error: bool = Field(
+        default=True,
+        description="Preserve workspace if execution fails (for debugging)",
+    )
+
+    # Resource Limits
+    max_workspace_size_mb: int = Field(
+        default=100,
+        ge=10,
+        le=1000,
+        description="Maximum workspace size in MB",
+    )
+    max_files_per_workspace: int = Field(
+        default=1000,
+        ge=10,
+        description="Maximum number of files in workspace",
+    )
+
+    @classmethod
+    def from_environment(cls) -> WorkspaceConfig:
+        """Create config from environment variables."""
+        return cls(
+            ttl_seconds=int(os.getenv("FRIDAY_SANDBOX_WORKSPACE_TTL", "3600")),
+            ttl_soft_limit_seconds=int(
+                os.getenv("FRIDAY_SANDBOX_WORKSPACE_TTL_SOFT", "3600")
+            ),
+            ttl_hard_limit_seconds=int(
+                os.getenv("FRIDAY_SANDBOX_WORKSPACE_TTL_HARD", "86400")
+            ),
+            cleanup_interval_seconds=int(
+                os.getenv("FRIDAY_SANDBOX_CLEANUP_INTERVAL", "300")
+            ),
+            preserve_on_error=os.getenv(
+                "FRIDAY_SANDBOX_PRESERVE_ON_ERROR", "true"
+            ).lower()
+            == "true",
+            max_workspace_size_mb=int(
+                os.getenv("FRIDAY_SANDBOX_MAX_WORKSPACE_SIZE_MB", "100")
+            ),
+            max_files_per_workspace=int(os.getenv("FRIDAY_SANDBOX_MAX_FILES", "1000")),
+        )
+
+
+class DockerConfig(BaseModel):
+    """
+    Configuration for Docker sandbox execution.
+
+    Controls container resources, networking, and security settings.
+    """
+
+    # Image Configuration
+    image: str = Field(
+        default="friday-sandbox-python:latest",
+        description="Docker image to use for execution",
+    )
+    pull_policy: str = Field(
+        default="if-not-present",
+        description="Image pull policy: always, if-not-present, never",
+    )
+
+    # Resource Limits
+    memory_limit: str = Field(
+        default="512m",
+        description="Container memory limit",
+    )
+    cpu_limit: float = Field(
+        default=1.0,
+        ge=0.1,
+        le=4.0,
+        description="CPU core limit",
+    )
+
+    # Execution Limits
+    default_timeout_seconds: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="Default execution timeout",
+    )
+    max_timeout_seconds: int = Field(
+        default=300,
+        ge=30,
+        le=600,
+        description="Maximum allowed timeout",
+    )
+
+    # Security
+    network_enabled: bool = Field(
+        default=False,
+        description="Enable network access in container",
+    )
+    read_only_rootfs: bool = Field(
+        default=True,
+        description="Mount root filesystem as read-only",
+    )
+    user: str = Field(
+        default="sandbox:sandbox",
+        description="User:group to run as in container",
+    )
+
+    # Paths
+    workspace_base_path: Path = Field(
+        default=Path("/tmp/friday-workspaces"),
+        description="Base path for workspace directories",
+    )
+
+    @field_validator("pull_policy")
+    @classmethod
+    def validate_pull_policy(cls, v: str) -> str:
+        valid = {"always", "if-not-present", "never"}
+        if v not in valid:
+            raise ValueError(f"pull_policy must be one of: {valid}")
+        return v
+
+    @classmethod
+    def from_environment(cls) -> DockerConfig:
+        """Create config from environment variables."""
+        return cls(
+            image=os.getenv("FRIDAY_SANDBOX_IMAGE", "friday-sandbox-python:latest"),
+            pull_policy=os.getenv("FRIDAY_SANDBOX_PULL_POLICY", "if-not-present"),
+            memory_limit=os.getenv("FRIDAY_SANDBOX_MEMORY_LIMIT", "512m"),
+            cpu_limit=float(os.getenv("FRIDAY_SANDBOX_CPU_LIMIT", "1.0")),
+            default_timeout_seconds=int(
+                os.getenv("FRIDAY_SANDBOX_DEFAULT_TIMEOUT", "30")
+            ),
+            max_timeout_seconds=int(os.getenv("FRIDAY_SANDBOX_MAX_TIMEOUT", "300")),
+            network_enabled=os.getenv("FRIDAY_SANDBOX_NETWORK_ENABLED", "false").lower()
+            == "true",
+            read_only_rootfs=os.getenv(
+                "FRIDAY_SANDBOX_READ_ONLY_ROOTFS", "true"
+            ).lower()
+            == "true",
+            workspace_base_path=Path(
+                os.getenv("FRIDAY_SANDBOX_WORKSPACE_PATH", "/tmp/friday-workspaces")
+            ),
+        )
+
+
+class SandboxConfig(BaseModel):
+    """
+    Top-level sandbox configuration combining all settings.
+    """
+
+    workspace: WorkspaceConfig = Field(default_factory=WorkspaceConfig)
+    docker: DockerConfig = Field(default_factory=DockerConfig)
+
+    # Sandbox Selection
+    sandbox_type: str = Field(
+        default="docker",
+        description="Sandbox type: docker, subprocess, mock",
+    )
+    fallback_to_subprocess: bool = Field(
+        default=True,
+        description="Fall back to subprocess if Docker unavailable",
+    )
+
+    @field_validator("sandbox_type")
+    @classmethod
+    def validate_sandbox_type(cls, v: str) -> str:
+        valid = {"docker", "subprocess", "mock"}
+        if v not in valid:
+            raise ValueError(f"sandbox_type must be one of: {valid}")
+        return v
+
+    @classmethod
+    def from_environment(cls) -> SandboxConfig:
+        """Create complete config from environment variables."""
+        return cls(
+            workspace=WorkspaceConfig.from_environment(),
+            docker=DockerConfig.from_environment(),
+            sandbox_type=os.getenv("FRIDAY_SANDBOX_TYPE", "docker"),
+            fallback_to_subprocess=os.getenv(
+                "FRIDAY_SANDBOX_FALLBACK_SUBPROCESS", "true"
+            ).lower()
+            == "true",
+        )
+
+    def merge_overrides(self, overrides: dict[str, Any]) -> SandboxConfig:
+        """
+        Create a new config with overrides applied.
+
+        Args:
+            overrides: Dictionary of override values.
+
+        Returns:
+            New SandboxConfig with overrides merged.
+        """
+        data = self.model_dump()
+        for key, value in overrides.items():
+            if "." in key:
+                # Handle nested keys like "workspace.ttl_seconds"
+                parts = key.split(".")
+                current = data
+                for part in parts[:-1]:
+                    current = current.setdefault(part, {})
+                current[parts[-1]] = value
+            else:
+                data[key] = value
+        return SandboxConfig.model_validate(data)