Sandbox Execution

# Required
DAYTONA_API_KEY=your_daytona_api_key_here

# Optional
DAYTONA_BASE_URL=https://api.daytona.io/v1  # Default

from src.daytona_runner import is_daytona_configured

if is_daytona_configured():
    print("Daytona is ready!")
else:
    print("Daytona not configured, will use local execution")

python forge.py --daytona

from forge import run_forge

result = run_forge(
    objective="Generate weekly AI events",
    use_daytona=True
)

# From forge.py:222-227
daytona_available = is_daytona_configured()
execution_mode = "daytona" if (use_daytona and daytona_available) else "local"
print(f"Execution: {execution_mode.upper()}")
if use_daytona and not daytona_available:
    print("  (Daytona not configured, falling back to local)")

Execution: DAYTONA

Execution: LOCAL
  (Daytona not configured, falling back to local)

# From daytona_runner.py:211-248
def run_all_candidates_in_daytona(
    candidates: list[dict],
    objective: str,
    artifacts_dir: Path,
    log_callback: Optional[Callable[[str, str], None]] = None,
) -> list[DaytonaResult]:
    """
    Run all candidates in Daytona sandboxes.

    Each candidate runs in its own isolated sandbox.
    """
    results = []

    for candidate in candidates:
        candidate_id = candidate["id"]
        script_path = candidate["script"]

        # Local output path (we'll copy artifact here after)
        output_dir = artifacts_dir / candidate_id
        output_dir.mkdir(parents=True, exist_ok=True)
        output_file = output_dir / "discord_post.md"

        # Run in Daytona
        result = run_candidate_in_daytona(
            candidate_id=candidate_id,
            script_path=script_path,
            objective=objective,
            output_file=str(output_file),
            log_callback=log_callback,
        )

        # Save artifact locally if we got one
        if result.artifact_content:
            output_file.write_text(result.artifact_content)

        results.append(result)

    return results

# From daytona_runner.py:38-47
@dataclass
class DaytonaResult:
    """Result from running a candidate in Daytona."""
    candidate_id: str
    sandbox_id: Optional[str]
    success: bool
    output: str
    artifact_content: Optional[str]
    runtime_seconds: float
    error_message: Optional[str] = None

DaytonaResult(
    candidate_id="gamma",
    sandbox_id="sb_kj4h2k3j4",
    success=True,
    output="[Gamma] Found 10 events\n[Gamma] Done!",
    artifact_content="# AI Events in the Bay Area\n...",
    runtime_seconds=3.2,
    error_message=None
)

# Install packages before running agent
install_cmd = "pip install requests beautifulsoup4"
sandbox.process.exec(install_cmd, timeout=60)

# Then run agent
run_cmd = f"python3 {sandbox_script_path} ..."
sandbox.process.exec(run_cmd, timeout=60)

# From daytona_runner.py:97-106
if not api_key:
    return DaytonaResult(
        candidate_id=candidate_id,
        sandbox_id=None,
        success=False,
        output="",
        artifact_content=None,
        runtime_seconds=0,
        error_message="Daytona API key not configured",
    )

# From daytona_runner.py:108-117
if not DAYTONA_AVAILABLE:
    return DaytonaResult(
        candidate_id=candidate_id,
        sandbox_id=None,
        success=False,
        output="",
        artifact_content=None,
        runtime_seconds=0,
        error_message="Daytona SDK not installed",
    )

# From daytona_runner.py:188-199
except Exception as e:
    elapsed = time.time() - start_time
    log(f"[Error] {str(e)[:50]}")
    return DaytonaResult(
        candidate_id=candidate_id,
        sandbox_id=sandbox_id,
        success=False,
        output="",
        artifact_content=None,
        runtime_seconds=elapsed,
        error_message=str(e),
    )

# From daytona_runner.py:50-59
def get_daytona_config() -> tuple[Optional[str], Optional[str]]:
    """Get Daytona API key and base URL from environment."""
    api_key = os.getenv("DAYTONA_API_KEY")
    base_url = os.getenv("DAYTONA_BASE_URL", "https://api.daytona.io/v1")

    # Filter out placeholder values
    if api_key and api_key.startswith("your_"):
        api_key = None

    return api_key, base_url

# Upload script: 30 seconds
write_result = sandbox.process.exec(write_cmd, timeout=30)

# Execute agent: 60 seconds
result = sandbox.process.exec(cmd, timeout=60)

# Retrieve artifact: 10 seconds
cat_result = sandbox.process.exec(f"cat {sandbox_output}", timeout=10)

# ❌ Bad: Reads local cache
cache = Path(".cache/data.json")
if cache.exists():
    return cache.read_text()

# ✅ Good: Self-contained
data = fetch_from_api()
return data

try:
    response = requests.get(url, timeout=5)
except requests.Timeout:
    print("[Agent] Timeout, skipping...")
    # Continue with partial results

print("[Agent] Starting fetch...")
print(f"[Agent] Processing {len(items)} items...")
print("[Agent] Writing output...")

# Fast iteration
python candidates/agent_custom.py "test" /tmp/out.md

# Then test in sandbox
python forge.py --daytona

# ✅ Standard library - works immediately
import urllib.request
import json

# ❌ External package - requires pip install in sandbox
import requests