Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=devops_sandbox
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,224 @@
----
-title: Devops Sandbox
-emoji: 😻
-colorFrom: pink
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Self-Healing DevOps Sandbox
+emoji: 🔧
+colorFrom: red
+colorTo: green
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+---
+
+# Self-Healing DevOps Sandbox
+
+An OpenEnv RL environment where an AI agent is dropped into a **broken Node.js backend** inside a Docker container. The agent must use **bash commands only** to diagnose bugs, edit files, and fix the app -- just like a real DevOps engineer would.
+
+Built for the **Meta PyTorch OpenEnv Hackathon**.
+
+---
+
+## What Is This?
+
+A 3-task challenge of increasing difficulty. The agent starts in a Docker container with a broken Express.js app in `/app` and must make all endpoints healthy.
+
+| # | Difficulty | Bug             | What's Wrong                          |
+|---|-----------|-----------------|---------------------------------------|
+| 1 | Easy      | `config.json`    | Port set to `9999` instead of `3000`  |
+| 2 | Medium    | `routes/users.js`| Missing `)` causes SyntaxError crash  |
+| 3 | Hard      | `routes/data.js` | Missing `await` causes HTTP 500       |
+
+**Goal:** Fix all bugs so these endpoints return HTTP 200:
+- `GET /health` returns `{"status": "ok"}`
+- `GET /api/users` returns `{"users": [...]}`
+- `GET /api/data` returns `{"records": [...]}`
+
+---
+
+## Scoring (Partial Rewards)
+
+The grader runs **after every command** and awards cumulative points:
+
+| Milestone                        | Points | Total    |
+|----------------------------------|--------|----------|
+| App starts on port 3000          | +0.35  | 0.35     |
+| `/health` returns 200            | +0.10  | 0.45     |
+| `/api/users` returns valid JSON  | +0.15  | 0.60     |
+| `/api/data` returns valid JSON   | +0.25  | 0.85     |
+| All endpoints correct            | +0.15  | **1.00** |
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- **Python 3.10+**
+- **Docker Desktop** (running)
+- **uv** package manager (`pip install uv`)
+
+### 1. Install Dependencies
+
+```bash
+cd devops_sandbox
+uv sync
+```
+
+### 2. Build the Sandbox Docker Image
+
+```bash
+docker build -t devops-sandbox-node:latest -f simulated_app/Dockerfile simulated_app/
+```
+
+### 3. Start the Environment Server
+
+```bash
+uv run server
+```
+
+The server starts at `http://localhost:8000`.
+
+### 4. Run the Baseline Agent
+
+In a **separate terminal**:
+
+```bash
+# Set your OpenAI API key
+export OPENAI_API_KEY="sk-..."          # Linux/Mac
+$env:OPENAI_API_KEY = "sk-..."          # PowerShell
+
+# Run the baseline
+uv run python baseline.py
+```
+
+---
+
+## Test Your Own Agent
+
+### Option A: Use the Python Client
+
+```python
+from devops_sandbox import BashAction, DevopsSandboxEnv
+
+with DevopsSandboxEnv(base_url="http://localhost:8000").sync() as env:
+    # Reset creates a fresh Docker container
+    result = env.reset()
+    print(result.observation.stdout)       # Task description
+    print(result.observation.grader_score)  # 0.0
+
+    # Send bash commands
+    result = env.step(BashAction(command="cat /app/config.json"))
+    print(result.observation.stdout)       # File contents
+    print(result.observation.grader_score)  # Score after grading
+
+    # Fix a bug
+    result = env.step(BashAction(command="sed -i 's/9999/3000/' /app/config.json"))
+    print(result.observation.grader_score)  # Partial score
+
+    # Check if done
+    if result.done:
+        print("Episode complete!")
+```
+
+### Option B: Use the REST API Directly
+
+```bash
+# Reset the environment
+curl -X POST http://localhost:8000/reset
+
+# Send a command
+curl -X POST http://localhost:8000/step \
+  -H "Content-Type: application/json" \
+  -d '{"action": {"command": "ls -la /app"}}'
+```
+
+### Option C: Use the WebSocket Endpoint
+
+Connect to `ws://localhost:8000/ws` for persistent sessions.
+
+---
+
+## Project Structure
+
+```
+devops_sandbox/
+|-- openenv.yaml                 # OpenEnv manifest
+|-- pyproject.toml               # Python dependencies
+|-- README.md                    # This file
+|-- baseline.py                  # LLM-powered baseline agent
+|-- models.py                    # BashAction & TerminalObservation schemas
+|-- client.py                    # Python client for the environment
+|
+|-- server/
+|   |-- app.py                   # FastAPI server (entry point)
+|   +-- devops_sandbox_environment.py  # Environment logic + grader
+|
++-- simulated_app/               # The broken Node.js app (Docker context)
+    |-- Dockerfile               # node:20-slim sandbox container
+    |-- package.json             # Express.js project
+    |-- server.js                # Main entry point
+    |-- config.json              # Bug 1: wrong port
+    +-- routes/
+        |-- users.js             # Bug 2: syntax error
+        +-- data.js              # Bug 3: missing await
+```
+
+---
+
+## How It Works
+
+```
++-----------+   BashAction    +------------+   docker exec   +--------------+
+|  Agent    | --------------> |  OpenEnv   | --------------> |  Docker      |
+| (LLM/RL) |                 |  Server    |                 |  Container   |
+|           | <-------------- |  (8000)    | <-------------- |  (broken app)|
++-----------+  Observation    +-----+------+   stdout/stderr +--------------+
+               + grader_score       |
+                              +-----+------+
+                              |   Grader   |
+                              | (curl test |
+                              |  endpoints)|
+                              +------------+
+```
+
+1. **Agent** sends a `BashAction` (e.g., `cat /app/config.json`)
+2. **Server** runs it inside the Docker container via `docker exec`
+3. **Grader** restarts the Node app and curls all endpoints
+4. **Observation** returns: stdout, stderr, score (0.0-1.0), feedback
+
+---
+
+## Configuration
+
+| Env Variable        | Default                  | Description                        |
+|--------------------|--------------------------|------------------------------------|
+| `OPENAI_API_KEY`    | *(required)*             | OpenAI API key for baseline        |
+| `OPENAI_MODEL`      | `gpt-4o-mini`            | LLM model to use                   |
+| `OPENAI_BASE_URL`   | *(OpenAI default)*       | Custom endpoint (Ollama, vLLM)     |
+| `MAX_TURNS`         | `30`                     | Max steps per episode              |
+| `DEVOPS_SANDBOX_URL`| `http://localhost:8000`  | Environment server URL             |
+
+### Use with Local LLMs (Ollama, vLLM)
+
+```bash
+export OPENAI_BASE_URL="http://localhost:11434/v1"
+export OPENAI_MODEL="llama3"
+export OPENAI_API_KEY="dummy"
+uv run python baseline.py
+```
+
+---
+
+## Validation
+
+```bash
+uv run openenv validate
+# Expected: [OK] devops_sandbox: Ready for multi-mode deployment
+```
+
+---
+
+## License
+
+BSD-style license. See LICENSE for details.

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Self-Healing DevOps Sandbox Environment."""
+
+from .client import DevopsSandboxEnv
+from .models import BashAction, TerminalObservation
+
+__all__ = [
+    "BashAction",
+    "TerminalObservation",
+    "DevopsSandboxEnv",
+]

_cli_path.txt

@@ -0,0 +1 @@
+E:\programs2\openenv(RL)\devops_sandbox\.venv\Lib\site-packages\openenv\cli

_path.txt

@@ -0,0 +1 @@
+E:\programs2\openenv(RL)\devops_sandbox\.venv\Lib\site-packages\openenv

baseline.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Baseline inference script for the Self-Healing DevOps Sandbox.
+
+Uses an LLM (via the OpenAI-compatible API) to diagnose and fix a broken
+Node.js backend running inside a Docker container.
+
+Usage:
+    export OPENAI_API_KEY="sk-..."
+    python baseline.py
+
+    # Or with a custom endpoint (e.g., local vLLM):
+    export OPENAI_BASE_URL="http://localhost:8080/v1"
+    python baseline.py
+"""
+
+import json
+import os
+import sys
+
+try:
+    from openai import OpenAI
+except ImportError:
+    print("ERROR: 'openai' package is required. Install with: pip install openai")
+    sys.exit(1)
+
+from devops_sandbox import BashAction, DevopsSandboxEnv
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+ENV_URL = os.getenv("DEVOPS_SANDBOX_URL", "http://localhost:8000")
+MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+MAX_TURNS = int(os.getenv("MAX_TURNS", "30"))
+
+SYSTEM_PROMPT = """\
+You are an expert DevOps engineer and Node.js developer.
+
+You have been dropped into a Linux container with a broken Express.js backend in /app.
+Your goal is to diagnose and fix ALL bugs so the app runs correctly.
+
+RULES:
+1. Respond ONLY with a JSON object: {"command": "<bash command>"}
+2. Use standard bash/Linux commands (ls, cat, grep, sed, node, npm, etc.)
+3. Do NOT use interactive editors (vi, nano). Use sed or echo/cat with redirection.
+4. After fixing bugs, restart the app with: cd /app && npm start &
+5. Be methodical: read files first, understand the bug, then fix it.
+
+EXPECTED FINAL STATE:
+- App starts without errors on port 3000
+- GET /health → 200
+- GET /api/users → 200 with JSON containing "users" array
+- GET /api/data → 200 with JSON containing "records" array
+"""
+
+
+def extract_command(llm_response: str) -> str:
+    """Extract a bash command from the LLM's response (JSON or raw text)."""
+    # Try JSON parsing first
+    try:
+        data = json.loads(llm_response.strip())
+        if isinstance(data, dict) and "command" in data:
+            return data["command"]
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+    # Try extracting from markdown code block
+    if "```" in llm_response:
+        lines = llm_response.split("```")
+        for block in lines[1::2]:  # odd indices are code blocks
+            code = block.strip()
+            if code.startswith("json"):
+                code = code[4:].strip()
+                try:
+                    data = json.loads(code)
+                    if isinstance(data, dict) and "command" in data:
+                        return data["command"]
+                except (json.JSONDecodeError, TypeError):
+                    pass
+            elif code.startswith("bash") or code.startswith("sh"):
+                code = code.split("\n", 1)[-1].strip()
+                return code
+            else:
+                first_line = code.split("\n")[0].strip()
+                if first_line:
+                    return first_line
+
+    # Fallback: treat entire response as a command
+    cmd = llm_response.strip().strip("`").strip()
+    if cmd.startswith("{"):
+        # One more try
+        try:
+            return json.loads(cmd)["command"]
+        except Exception:
+            pass
+    return cmd
+
+
+def main():
+    print("=" * 60)
+    print(" Self-Healing DevOps Sandbox — Baseline Agent")
+    print("=" * 60)
+
+    client = OpenAI()
+
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+    with DevopsSandboxEnv(base_url=ENV_URL).sync() as env:
+        # Reset the environment
+        print("\n[*] Resetting environment...")
+        result = env.reset()
+        obs = result.observation
+
+        print(f"\n[INIT] Task prompt:\n{obs.stdout[:500]}...")
+        print(f"[INIT] Score: {obs.grader_score} | Feedback: {obs.grader_feedback}")
+
+        # Add initial observation to messages
+        messages.append({
+            "role": "user",
+            "content": (
+                f"Here is the initial state of the broken app:\n\n"
+                f"```\n{obs.stdout}\n```\n\n"
+                f"Current directory: {obs.current_dir}\n"
+                f"Score: {obs.grader_score}/1.0\n\n"
+                f"What bash command should I run first?"
+            ),
+        })
+
+        for turn in range(1, MAX_TURNS + 1):
+            print(f"\n{'─' * 40}")
+            print(f"Turn {turn}/{MAX_TURNS}")
+            print(f"{'─' * 40}")
+
+            # Get LLM response
+            try:
+                response = client.chat.completions.create(
+                    model=MODEL,
+                    messages=messages,
+                    temperature=0.2,
+                    max_tokens=256,
+                )
+                llm_text = response.choices[0].message.content or ""
+            except Exception as e:
+                print(f"[ERROR] LLM call failed: {e}")
+                break
+
+            # Extract command
+            command = extract_command(llm_text)
+            if not command:
+                print("[WARN] Could not extract command from LLM response")
+                command = "ls -la /app"
+
+            print(f"[CMD] {command}")
+
+            # Execute in environment
+            result = env.step(BashAction(command=command))
+            obs = result.observation
+
+            stdout_preview = obs.stdout[:300] if obs.stdout else "(empty)"
+            stderr_preview = obs.stderr[:200] if obs.stderr else "(none)"
+            print(f"[OUT] {stdout_preview}")
+            if obs.stderr:
+                print(f"[ERR] {stderr_preview}")
+            print(f"[SCORE] {obs.grader_score:.2f} | {obs.grader_feedback}")
+
+            # Add to conversation
+            messages.append({"role": "assistant", "content": llm_text})
+            messages.append({
+                "role": "user",
+                "content": (
+                    f"Command output:\n"
+                    f"stdout:\n```\n{obs.stdout}\n```\n"
+                    f"stderr:\n```\n{obs.stderr}\n```\n"
+                    f"Current score: {obs.grader_score}/1.0\n"
+                    f"Grader feedback: {obs.grader_feedback}\n\n"
+                    f"What command should I run next?"
+                ),
+            })
+
+            # Check if done
+            if result.done:
+                print(f"\n{'=' * 60}")
+                if obs.grader_score >= 1.0:
+                    print(" ✅ ALL BUGS FIXED — PERFECT SCORE!")
+                else:
+                    print(f" Episode ended. Final score: {obs.grader_score:.2f}/1.0")
+                print(f"{'=' * 60}")
+                break
+        else:
+            print(f"\n[!] Max turns ({MAX_TURNS}) reached.")
+            print(f"    Final score: {obs.grader_score:.2f}/1.0")
+
+    print("\n[*] Done.")
+
+
+if __name__ == "__main__":
+    main()

client.py

@@ -0,0 +1,65 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Self-Healing DevOps Sandbox Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import BashAction, TerminalObservation
+
+
+class DevopsSandboxEnv(
+    EnvClient[BashAction, TerminalObservation, State]
+):
+    """
+    Client for the Self-Healing DevOps Sandbox Environment.
+
+    Example:
+        >>> with DevopsSandboxEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.stdout)
+        ...
+        ...     result = client.step(BashAction(command="ls -la"))
+        ...     print(result.observation.stdout)
+    """
+
+    def _step_payload(self, action: BashAction) -> Dict:
+        """Convert BashAction to JSON payload for step message."""
+        return {
+            "command": action.command,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[TerminalObservation]:
+        """Parse server response into StepResult[TerminalObservation]."""
+        obs_data = payload.get("observation", {})
+        observation = TerminalObservation(
+            stdout=obs_data.get("stdout", ""),
+            stderr=obs_data.get("stderr", ""),
+            current_dir=obs_data.get("current_dir", "/app"),
+            task_id=obs_data.get("task_id", "devops_sandbox"),
+            grader_score=obs_data.get("grader_score", 0.0),
+            grader_feedback=obs_data.get("grader_feedback", ""),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """Parse server response into State object."""
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

devops_troubleshooting_sandbox.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: devops-troubleshooting-sandbox
+Version: 0.1.0
+Summary: A real-world DevOps environment where an agent must diagnose and fix broken backend configurations inside an isolated Docker container.
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.1
+Requires-Dist: openai>=1.0.0

devops_troubleshooting_sandbox.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+__init__.py
+client.py
+models.py
+pyproject.toml
+./__init__.py
+./baseline.py
+./client.py
+./models.py
+devops_troubleshooting_sandbox.egg-info/PKG-INFO
+devops_troubleshooting_sandbox.egg-info/SOURCES.txt
+devops_troubleshooting_sandbox.egg-info/dependency_links.txt
+devops_troubleshooting_sandbox.egg-info/entry_points.txt
+devops_troubleshooting_sandbox.egg-info/requires.txt
+devops_troubleshooting_sandbox.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/devops_sandbox_environment.py

devops_troubleshooting_sandbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devops_troubleshooting_sandbox.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = devops_sandbox.server.app:main

devops_troubleshooting_sandbox.egg-info/requires.txt

@@ -0,0 +1,2 @@
+openenv-core[core]>=0.2.1
+openai>=1.0.0

devops_troubleshooting_sandbox.egg-info/top_level.txt

@@ -0,0 +1 @@
+devops_sandbox

models.py

@@ -0,0 +1,70 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the Self-Healing DevOps Sandbox Environment.
+
+Defines the Action and Observation types used by the RL agent to interact
+with a broken Node.js backend running inside a Docker container.
+"""
+
+from typing import Any, Dict
+
+from pydantic import Field
+
+from openenv.core.env_server.types import Action, Observation
+
+
+class BashAction(Action):
+    """Action: a bash command to execute inside the Docker sandbox.
+
+    The agent sends shell commands (ls, cat, sed, node, etc.) to diagnose
+    and repair the broken Node.js application.
+    """
+
+    command: str = Field(
+        ...,
+        description=(
+            "The bash command to execute in the sandbox terminal "
+            "(e.g., 'ls -la', 'cat server.js', "
+            "'sed -i s/old/new/ file.js')."
+        ),
+    )
+
+
+class TerminalObservation(Observation):
+    """Observation returned after executing a bash command.
+
+    Includes stdout/stderr from the command, working directory context,
+    the current task identifier, and the grader's partial score.
+    """
+
+    stdout: str = Field(
+        default="",
+        description="Standard output from the executed command.",
+    )
+    stderr: str = Field(
+        default="",
+        description="Standard error from the executed command, if any.",
+    )
+    current_dir: str = Field(
+        default="/app",
+        description="The current working directory inside the container.",
+    )
+    task_id: str = Field(
+        default="devops_sandbox",
+        description="Identifier for the current task scenario.",
+    )
+    grader_score: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=1.0,
+        description="The grader's partial reward (0.0 to 1.0).",
+    )
+    grader_feedback: str = Field(
+        default="",
+        description="Human-readable feedback from the grader.",
+    )

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: devops_sandbox
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

openenv_devops_sandbox.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: openenv-devops_sandbox
+Version: 0.1.0
+Summary: Devops Sandbox environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_devops_sandbox.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+openenv_devops_sandbox.egg-info/PKG-INFO
+openenv_devops_sandbox.egg-info/SOURCES.txt
+openenv_devops_sandbox.egg-info/dependency_links.txt
+openenv_devops_sandbox.egg-info/entry_points.txt
+openenv_devops_sandbox.egg-info/requires.txt
+openenv_devops_sandbox.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/devops_sandbox_environment.py

openenv_devops_sandbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_devops_sandbox.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = devops_sandbox.server.app:main

openenv_devops_sandbox.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.1
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_devops_sandbox.egg-info/top_level.txt

@@ -0,0 +1 @@
+devops_sandbox

pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devops-troubleshooting-sandbox"
+version = "0.1.0"
+description = "A real-world DevOps environment where an agent must diagnose and fix broken backend configurations inside an isolated Docker container."
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core[core]>=0.2.1",
+    "openai>=1.0.0",
+]
+
+[project.scripts]
+# This line fixes the "Missing [project.scripts]" error
+server = "devops_sandbox.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["devops_sandbox", "devops_sandbox.server"]
+package-dir = { "devops_sandbox" = ".", "devops_sandbox.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Self-Healing DevOps Sandbox environment server components."""
+
+from .devops_sandbox_environment import DevOpsSandbox
+
+__all__ = ["DevOpsSandbox"]

server/app.py

@@ -0,0 +1,59 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Self-Healing DevOps Sandbox Environment.
+
+Endpoints:
+    - POST /reset: Reset the environment (build & start container)
+    - POST /step: Execute a bash command inside the container
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required. Install with:\n    uv sync\n"
+    ) from e
+
+try:
+    from ..models import BashAction, TerminalObservation
+    from .devops_sandbox_environment import DevOpsSandbox
+except (ImportError, ModuleNotFoundError):
+    from models import BashAction, TerminalObservation
+    from server.devops_sandbox_environment import DevOpsSandbox
+
+
+# Create the app — DevOpsSandbox is passed as a class (factory mode)
+app = create_app(
+    DevOpsSandbox,
+    BashAction,
+    TerminalObservation,
+    env_name="devops_sandbox",
+    max_concurrent_envs=1,
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution.
+
+        uv run --project . server
+        python -m devops_sandbox.server.app
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/devops_sandbox_environment.py

@@ -0,0 +1,450 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Self-Healing DevOps Sandbox — Environment Implementation.
+
+Spins up an isolated Docker container with a broken Node.js backend.
+The RL agent executes bash commands to diagnose and fix 3 bugs.
+A programmatic grader awards partial credit (0.0 → 1.0) after every step.
+"""
+
+import logging
+import os
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Optional
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import BashAction, TerminalObservation
+except ImportError:
+    from models import BashAction, TerminalObservation
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+CONTAINER_NAME_PREFIX = "devops_sandbox_"
+IMAGE_NAME = "devops-sandbox-node:latest"
+EXPECTED_PORT = 3000          # The port the fixed app should listen on
+MAX_STEPS = 50                # Episode budget
+SIMULATED_APP_DIR = Path(__file__).resolve().parent.parent / "simulated_app"
+
+
+class DevOpsSandbox(Environment):
+    """
+    RL environment: fix a broken Node.js backend inside a Docker container.
+
+    reset() → build image (if needed) + start container + return initial obs
+    step()  → docker exec the agent's command + run grader → obs + reward
+    close() → tear down container
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = False
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+    def __init__(self):
+        super().__init__()
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._container_name: Optional[str] = None
+        self._container_running: bool = False
+        self._current_dir: str = "/app"
+        self._last_score: float = 0.0
+
+    # ------------------------------------------------------------------
+    # reset
+    # ------------------------------------------------------------------
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> TerminalObservation:
+        """Build the Docker image, start the container, return the task prompt."""
+        # Cleanup previous episode
+        self._cleanup_container()
+
+        # New episode
+        eid = episode_id or str(uuid4())
+        self._state = State(episode_id=eid, step_count=0)
+        self._last_score = 0.0
+        self._current_dir = "/app"
+
+        # Build image (idempotent — Docker caches layers)
+        self._build_image()
+
+        # Start container
+        self._container_name = f"{CONTAINER_NAME_PREFIX}{eid[:8]}"
+        self._start_container()
+
+        # Inject the grader script into the container
+        self._inject_grader_script()
+
+        # Gather initial observation
+        init_stdout = self._docker_exec("ls -la /app && echo '---' && cat /app/config.json")
+
+        task_prompt = (
+            "=== SELF-HEALING DEVOPS SANDBOX ===\n"
+            "You have been dropped into a Docker container with a broken Node.js "
+            "Express backend in /app.\n\n"
+            "YOUR MISSION: Diagnose and fix ALL bugs so that:\n"
+            "  1. The app starts without errors on port 3000\n"
+            "  2. GET /health returns HTTP 200\n"
+            "  3. GET /api/users returns HTTP 200 with valid JSON\n"
+            "  4. GET /api/data returns HTTP 200 with valid JSON\n\n"
+            "HINTS:\n"
+            "  - Check config files for wrong settings\n"
+            "  - Look for syntax errors that prevent startup\n"
+            "  - Watch out for async/await issues\n\n"
+            "Use bash commands to explore, edit files, and test.\n"
+            "When you think you've fixed everything, run: npm start\n\n"
+            "--- INITIAL DIRECTORY LISTING ---\n"
+            f"{init_stdout}\n"
+        )
+
+        return TerminalObservation(
+            stdout=task_prompt,
+            stderr="",
+            current_dir=self._current_dir,
+            task_id="devops_sandbox",
+            grader_score=0.0,
+            grader_feedback="Episode started. Fix the bugs!",
+            done=False,
+            reward=0.0,
+        )
+
+    # ------------------------------------------------------------------
+    # step
+    # ------------------------------------------------------------------
+    def step(
+        self,
+        action: BashAction,  # type: ignore[override]
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> TerminalObservation:
+        """Execute the agent's bash command, run grader, return observation."""
+        self._state.step_count += 1
+
+        if not self._container_running:
+            return TerminalObservation(
+                stdout="",
+                stderr="ERROR: Container is not running. Call reset() first.",
+                current_dir=self._current_dir,
+                task_id="devops_sandbox",
+                grader_score=0.0,
+                grader_feedback="Container not running.",
+                done=True,
+                reward=0.0,
+            )
+
+        # Execute the command
+        command = action.command.strip()
+        if not command:
+            return TerminalObservation(
+                stdout="",
+                stderr="Empty command. Please provide a bash command.",
+                current_dir=self._current_dir,
+                task_id="devops_sandbox",
+                grader_score=self._last_score,
+                grader_feedback="No command executed.",
+                done=False,
+                reward=self._last_score,
+            )
+
+        try:
+            timeout = timeout_s or 30.0
+            stdout, stderr = self._docker_exec_split(command, timeout=timeout)
+        except Exception as e:
+            stdout, stderr = "", f"Command execution error: {e}"
+
+        # Run the grader
+        score, feedback = self._grade()
+        self._last_score = score
+
+        episode_done = (score >= 1.0) or (self._state.step_count >= MAX_STEPS)
+
+        return TerminalObservation(
+            stdout=stdout,
+            stderr=stderr,
+            current_dir=self._current_dir,
+            task_id="devops_sandbox",
+            grader_score=score,
+            grader_feedback=feedback,
+            done=episode_done,
+            reward=score,
+        )
+
+    # ------------------------------------------------------------------
+    # state
+    # ------------------------------------------------------------------
+    @property
+    def state(self) -> State:
+        return self._state
+
+    # ------------------------------------------------------------------
+    # close
+    # ------------------------------------------------------------------
+    def close(self) -> None:
+        self._cleanup_container()
+
+    # ==================================================================
+    #  GRADER — partial reward (0.0 → 1.0)
+    #  The grader script is injected as a file into the container at
+    #  reset() time, then executed via `bash /tmp/grader.sh` to avoid
+    #  Windows subprocess escaping issues with complex bash scripts.
+    # ==================================================================
+    def _inject_grader_script(self) -> None:
+        """Write the grader bash script into the container as /tmp/grader.sh."""
+        # Use a heredoc via docker exec to write the file
+        # We write it line-by-line to avoid any escaping issues
+        lines = [
+            '#!/bin/bash',
+            'set -m',
+            '',
+            'pkill -f "node server.js" 2>/dev/null',
+            'sleep 0.5',
+            '',
+            'cd /app',
+            'node server.js > /tmp/node.log 2>&1 &',
+            'NODE_PID=$!',
+            '',
+            'for i in 1 2 3 4; do',
+            '  sleep 1',
+            '  if curl -s http://localhost:3000/health > /dev/null 2>&1; then',
+            '    break',
+            '  fi',
+            'done',
+            '',
+            'STARTUP_LOG=$(cat /tmp/node.log 2>/dev/null)',
+            '',
+            "HEALTH_CODE=$(curl -s -o /tmp/health.json -w '%{http_code}' http://localhost:3000/health 2>/dev/null)",
+            "USERS_CODE=$(curl -s -o /tmp/users.json -w '%{http_code}' http://localhost:3000/api/users 2>/dev/null)",
+            "DATA_CODE=$(curl -s -o /tmp/data.json -w '%{http_code}' http://localhost:3000/api/data 2>/dev/null)",
+            'USERS_BODY=$(cat /tmp/users.json 2>/dev/null)',
+            'DATA_BODY=$(cat /tmp/data.json 2>/dev/null)',
+            '',
+            'kill $NODE_PID 2>/dev/null',
+            'wait $NODE_PID 2>/dev/null',
+            '',
+            'echo "GRADER_STARTUP_LOG:${STARTUP_LOG}"',
+            'echo "GRADER_HEALTH_CODE:${HEALTH_CODE}"',
+            'echo "GRADER_USERS_CODE:${USERS_CODE}"',
+            'echo "GRADER_DATA_CODE:${DATA_CODE}"',
+            'echo "GRADER_USERS_BODY:${USERS_BODY}"',
+            'echo "GRADER_DATA_BODY:${DATA_BODY}"',
+        ]
+        script_content = '\n'.join(lines) + '\n'
+
+        # Write via docker cp using a temp file on the host
+        import tempfile
+        with tempfile.NamedTemporaryFile(
+            mode='w', suffix='.sh', delete=False, newline='\n'
+        ) as f:
+            f.write(script_content)
+            tmp_path = f.name
+
+        try:
+            subprocess.run(
+                ["docker", "cp", tmp_path, f"{self._container_name}:/tmp/grader.sh"],
+                check=True,
+                capture_output=True,
+                timeout=10,
+            )
+            self._docker_exec("chmod +x /tmp/grader.sh")
+        finally:
+            os.unlink(tmp_path)
+
+    def _grade(self) -> tuple:
+        """
+        Run the grader script inside the container.
+        Returns (score: float, feedback: str).
+        """
+        score = 0.0
+        feedback_parts = []
+
+        try:
+            raw = self._docker_exec("bash /tmp/grader.sh", timeout=20.0)
+
+            # Parse structured output
+            results = {}
+            for line in raw.splitlines():
+                if line.startswith("GRADER_"):
+                    key, _, value = line.partition(":")
+                    results[key] = value.strip()
+
+            startup_log = results.get("GRADER_STARTUP_LOG", "")
+            health_code = results.get("GRADER_HEALTH_CODE", "000")
+            users_code = results.get("GRADER_USERS_CODE", "000")
+            data_code = results.get("GRADER_DATA_CODE", "000")
+            users_body = results.get("GRADER_USERS_BODY", "")
+            data_body = results.get("GRADER_DATA_BODY", "")
+
+            # --- Check 1: App starts on correct port ---
+            has_syntax_error = "SyntaxError" in startup_log
+            has_crash = (has_syntax_error
+                         or "Cannot find module" in startup_log
+                         or "ReferenceError" in startup_log)
+            app_listening = f"Server running on port {EXPECTED_PORT}" in startup_log
+
+            if has_crash and not app_listening:
+                feedback_parts.append(f"✗ App crashes on startup")
+                if has_syntax_error:
+                    feedback_parts.append("(SyntaxError detected)")
+                return (score, " | ".join(feedback_parts))
+
+            if app_listening:
+                score += 0.35
+                feedback_parts.append("✓ App starts on port 3000 (+0.35)")
+            else:
+                feedback_parts.append("✗ App not listening on port 3000")
+                return (score, " | ".join(feedback_parts))
+
+            # --- Check 2: /health ---
+            if health_code == "200":
+                score += 0.10
+                feedback_parts.append("✓ /health returns 200 (+0.10)")
+            else:
+                feedback_parts.append(f"✗ /health returned {health_code}")
+
+            # --- Check 3: /api/users ---
+            if users_code == "200":
+                if '"users"' in users_body:
+                    score += 0.15
+                    feedback_parts.append("✓ /api/users returns valid JSON (+0.15)")
+                else:
+                    score += 0.05
+                    feedback_parts.append("~ /api/users 200 but bad body (+0.05)")
+            else:
+                feedback_parts.append(f"✗ /api/users returned {users_code}")
+
+            # --- Check 4: /api/data ---
+            if data_code == "200":
+                if '"records"' in data_body:
+                    score += 0.25
+                    feedback_parts.append("✓ /api/data returns valid JSON (+0.25)")
+                else:
+                    score += 0.05
+                    feedback_parts.append("~ /api/data 200 but bad body (+0.05)")
+            else:
+                feedback_parts.append(f"✗ /api/data returned {data_code}")
+
+            # --- Check 5: all endpoints correct ---
+            if score >= 0.85:
+                score = min(score + 0.15, 1.0)
+                feedback_parts.append("✓ All endpoints healthy — FULL SCORE (+0.15)")
+
+        except Exception as exc:
+            logger.exception("Grader error")
+            feedback_parts.append(f"Grader error (score preserved): {exc}")
+
+        score = round(min(max(score, 0.0), 1.0), 2)
+        return (score, " | ".join(feedback_parts))
+
+    # ==================================================================
+    #  DOCKER HELPERS
+    # ==================================================================
+    def _build_image(self) -> None:
+        """Build the sandbox Docker image from simulated_app/."""
+        try:
+            logger.info("Building Docker image %s …", IMAGE_NAME)
+            subprocess.run(
+                ["docker", "build", "-t", IMAGE_NAME, "."],
+                cwd=str(SIMULATED_APP_DIR),
+                check=True,
+                capture_output=True,
+                timeout=120,
+            )
+            logger.info("Docker image built successfully.")
+        except subprocess.CalledProcessError as e:
+            logger.error("Docker build failed: %s", e.stderr.decode(errors="replace"))
+            raise RuntimeError(f"Docker build failed: {e.stderr.decode(errors='replace')}") from e
+        except FileNotFoundError:
+            raise RuntimeError(
+                "Docker CLI not found. Ensure Docker is installed and on PATH."
+            )
+
+    def _start_container(self) -> None:
+        """Run the sandbox container in detached mode."""
+        try:
+            # Remove stale container with same name
+            subprocess.run(
+                ["docker", "rm", "-f", self._container_name],
+                capture_output=True,
+                timeout=10,
+            )
+            subprocess.run(
+                [
+                    "docker", "run", "-d",
+                    "--init",
+                    "--name", self._container_name,
+                    IMAGE_NAME,
+                ],
+                check=True,
+                capture_output=True,
+                timeout=30,
+            )
+            self._container_running = True
+            logger.info("Container %s started.", self._container_name)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(
+                f"Failed to start container: {e.stderr.decode(errors='replace')}"
+            ) from e
+
+    def _docker_exec(self, cmd: str, timeout: float = 30.0) -> str:
+        """Execute a command inside the running container and return combined output."""
+        try:
+            result = subprocess.run(
+                ["docker", "exec", self._container_name, "bash", "-c", cmd],
+                capture_output=True,
+                timeout=timeout,
+            )
+            out = result.stdout.decode(errors="replace")
+            err = result.stderr.decode(errors="replace")
+            return (out + err).strip()
+        except subprocess.TimeoutExpired:
+            return "[command timed out]"
+        except Exception as e:
+            return f"[docker exec error: {e}]"
+
+    def _docker_exec_split(self, cmd: str, timeout: float = 30.0) -> tuple:
+        """Execute command; return (stdout, stderr) separately."""
+        try:
+            result = subprocess.run(
+                ["docker", "exec", self._container_name, "bash", "-c", cmd],
+                capture_output=True,
+                timeout=timeout,
+            )
+            return (
+                result.stdout.decode(errors="replace"),
+                result.stderr.decode(errors="replace"),
+            )
+        except subprocess.TimeoutExpired:
+            return ("", "[command timed out]")
+        except Exception as e:
+            return ("", f"[docker exec error: {e}]")
+
+    def _cleanup_container(self) -> None:
+        """Stop and remove the container if it exists."""
+        if self._container_name:
+            try:
+                subprocess.run(
+                    ["docker", "rm", "-f", self._container_name],
+                    capture_output=True,
+                    timeout=15,
+                )
+                logger.info("Container %s removed.", self._container_name)
+            except Exception:
+                pass
+        self._container_running = False
+        self._container_name = None

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

simulated_app/Dockerfile

@@ -0,0 +1,26 @@
+# Lightweight Node.js image for the DevOps Sandbox
+FROM node:20-slim
+
+# Install bash, git, curl, and common debugging tools
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        bash \
+        git \
+        curl \
+        procps \
+        sed \
+        grep \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy the buggy application
+COPY package.json /app/package.json
+RUN npm install --production 2>/dev/null || true
+
+COPY . /app
+
+# The container stays alive so the agent can interact via `docker exec`
+# The agent is responsible for starting/restarting the Node app.
+CMD ["tail", "-f", "/dev/null"]

simulated_app/config.json

@@ -0,0 +1,5 @@
+{
+  "port": 9999,
+  "appName": "DevOps Sandbox App",
+  "version": "1.0.0"
+}

simulated_app/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "devops-sandbox-app",
+  "version": "1.0.0",
+  "description": "A simple Express.js backend for the DevOps Sandbox environment",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2"
+  }
+}

simulated_app/routes/data.js

@@ -0,0 +1,37 @@
+const express = require('express');
+const router = express.Router();
+
+// Simulates fetching data from a database
+function fetchDataFromDB() {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve({
+        records: [
+          { id: 1, value: 'sensor_alpha', reading: 42.5 },
+          { id: 2, value: 'sensor_beta', reading: 17.3 },
+          { id: 3, value: 'sensor_gamma', reading: 88.1 }
+        ],
+        timestamp: new Date().toISOString()
+      });
+    }, 100);
+  });
+}
+
+// BUG 3 (Hard): The handler is marked async but does NOT await the Promise.
+// This means `result` will be a pending Promise object, not the resolved data.
+// Express will try to serialize the Promise, resulting in an empty/broken response
+// or a 500 error when the client expects valid JSON.
+
+router.get('/', async (req, res) => {
+  try {
+    const result = fetchDataFromDB();
+    if (!result || !result.records) {
+      return res.status(500).json({ error: 'Failed to fetch data' });
+    }
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+module.exports = router;

simulated_app/routes/users.js

@@ -0,0 +1,18 @@
+const express = require('express');
+const router = express.Router();
+
+// BUG 2 (Medium): There is a syntax error below.
+// The closing parenthesis for router.get() is missing,
+// which will cause Node.js to crash on startup with a SyntaxError.
+
+const users = [
+  { id: 1, name: 'Alice', email: 'alice@example.com' },
+  { id: 2, name: 'Bob', email: 'bob@example.com' },
+  { id: 3, name: 'Charlie', email: 'charlie@example.com' }
+];
+
+router.get('/', (req, res) => {
+  res.json({ users: users });
+};
+
+module.exports = router;

simulated_app/server.js

@@ -0,0 +1,23 @@
+const express = require('express');
+const config = require('./config.json');
+
+const app = express();
+app.use(express.json());
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', uptime: process.uptime() });
+});
+
+// Mount route modules
+const usersRouter = require('./routes/users');
+const dataRouter = require('./routes/data');
+
+app.use('/api/users', usersRouter);
+app.use('/api/data', dataRouter);
+
+// Start server on the port from config
+const PORT = config.port;
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`Server running on port ${PORT}`);
+});