baseline runner and dockerfile additions

.dockerignore

@@ -0,0 +1,94 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv/
+.env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+
+# Documentation
+README.md
+docs/
+
+# Test files
+tests/
+test_*.py
+*_test.py
+conftest.py
+
+# CI/CD
+.github/
+.gitlab-ci.yml
+.travis.yml
+
+# Development files
+.env
+.env.local
+.env.*.local
+!.env.example
+
+# Dataset cache (will be downloaded at runtime if needed)
+.cache/
+datasets-cache/
+.huggingface/
+
+# Baseline results (generated at runtime)
+baseline/baseline_results.json
+
+# Node modules (if any JS tools are used)
+node_modules/
+
+# Docker
+Dockerfile.*
+docker-compose*.yml

Dockerfile

@@ -14,72 +14,61 @@ ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
 FROM ghcr.io/meta-pytorch/openenv-base:latest AS builder
 
 WORKDIR /app
-
-# Build argument to control whether we're building standalone or in-repo
 ARG BUILD_MODE=in-repo
 
-# Copy environment code (always at root of build context)
 COPY . /app/env
-
-# For in-repo builds, openenv-core is already in the pyproject.toml dependencies
-# For standalone builds, openenv-core will be installed from pip via pyproject.toml
 WORKDIR /app/env
 
-# Ensure uv is available (for local builds where base image lacks it)
+# Ensure uv is available
 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 git for building from git repos (build-time only)
+# Install git
 RUN apt-get update && apt-get install -y --no-install-recommends \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-# Install dependencies using uv sync
-# First pass: install dependencies without the project (for better caching)
-# Second pass: install the project itself
+# Install uv properly
 RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
     install -m 0755 /root/.local/bin/uv /usr/local/bin/uv && \
     install -m 0755 /root/.local/bin/uvx /usr/local/bin/uvx
 
+# Two-pass install for better layer caching
 RUN --mount=type=cache,target=/root/.cache/uv \
-    if [ -f uv.lock ]; then \
-        uv sync --no-install-project --no-editable; \
-    else \
-        uv sync --no-install-project --no-editable; \
-    fi
+    uv sync --no-install-project --no-editable
 
 RUN --mount=type=cache,target=/root/.cache/uv \
-    if [ -f uv.lock ]; then \
-        uv sync --no-editable; \
-    else \
-        uv sync --no-editable; \
-    fi
+    uv sync --no-editable
 
-# Final runtime stage
+# ── Runtime stage ──────────────────────────────────────────────────
 FROM ghcr.io/meta-pytorch/openenv-base:latest
 
 WORKDIR /app
 
-# Copy the virtual environment from builder
+# Copy venv and code 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
+# Environment
 ENV PATH="/app/.venv/bin:$PATH"
-
-# Set PYTHONPATH so imports work correctly
 ENV PYTHONPATH="/app/env:$PYTHONPATH"
+ENV PYTHONUNBUFFERED=1
 ENV ENABLE_WEB_INTERFACE=true
 
-# Health check using Python (more portable than curl/wget)
+# Never bake API key into image — must be passed at runtime
+# docker run --env OPENAI_API_KEY=sk-... idpi-exfil-env
+ENV OPENAI_API_KEY=""
+
+# Expose port
+EXPOSE 8000
+
+# Health check
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
     CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
 
-# Run the FastAPI server
-# The module path is constructed to work with the /app/env structure
-CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]
+# Default: start server
+# Override with: docker run --env OPENAI_API_KEY=sk-... idpi-exfil-env python run_baseline.py
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

baseline/run_baseline.py

@@ -185,7 +185,7 @@ def get_model_action(client: OpenAI, observation, step_count: int) -> Action:
         return Action(type="NoOp")  # Safe fallback
 
 
-async def run_difficulty_baseline(client: OpenAI, difficulty: str, env: IDPIExfilEnv) -> Dict[str, Any]:
+def run_difficulty_baseline(client: OpenAI, difficulty: str, env: IDPIExfilEnv) -> Dict[str, Any]:
     """Run baseline for a specific difficulty level."""
     print(f"\n{'='*50}")
     print(f"Running {difficulty.upper()} difficulty baseline")
@@ -291,49 +291,46 @@ async def run_difficulty_baseline(client: OpenAI, difficulty: str, env: IDPIExfi
         }
     }
 
+from datetime import datetime, timezone
 
-async def main() -> None:
-    """Main baseline runner."""
+def main() -> None:
     print("IDPI Exfil Environment - GPT-4o Baseline Runner")
     print("=" * 50)
 
-    # Initialize OpenAI client
     client = OpenAI(api_key=OPENAI_API_KEY)
-
-    # Initialize environment
     env = IDPIExfilEnv()
 
-    # Run baseline for all difficulties
     all_results = []
     for difficulty in DIFFICULTIES:
-        result = await run_difficulty_baseline(client, difficulty, env)
+        result = run_difficulty_baseline(client, difficulty, env)
         all_results.append(result)
 
-    # Save results
     output = {
         "model": MODEL_NAME,
-        "timestamp": "2024-01-01T00:00:00Z",  # Would use actual timestamp
+        "timestamp": datetime.now(timezone.utc).isoformat(),
         "results": all_results
     }
 
+    os.makedirs("baseline", exist_ok=True)
     with open("baseline/baseline_results.json", "w") as f:
         json.dump(output, f, indent=2)
 
     print(f"\n{'='*50}")
     print("BASELINE RUN COMPLETE")
-    print("Results saved to baseline/baseline_results.json")
     print(f"{'='*50}")
 
-    # Print summary
     for result in all_results:
         diff = result["difficulty"]
         summary = result["summary"]
         print(f"\n{diff.upper()} DIFFICULTY:")
-        print(".1f")
-        print(".1f")
-        print(".1f")
-        print(".1f")
+        print(f"  Success Rate: {summary['success_rate']*100:.1f}%")
+        print(f"  Avg Score:    {summary['avg_score']:.3f}")
+        print(f"  Std Score:    {summary['std_score']:.3f}")
+        print(f"  Avg Steps:    {summary['avg_steps']:.1f}")
 
+    overall_avg = sum(r["summary"]["avg_score"] for r in all_results) / len(all_results)
+    print(f"\nOVERALL AVERAGE SCORE: {overall_avg:.3f}")
+    print(f"Results saved to baseline/baseline_results.json")
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

run_baseline.py

@@ -2,19 +2,19 @@
 """
 IDPI Exfil Environment - Baseline Runner
 
-This script runs GPT-4o against the IDPI Exfil Environment to establish
+Runs GPT-4o against the IDPI Exfil Environment to establish
 baseline performance across easy, medium, and hard difficulty levels.
 
 Requirements:
-- OPENAI_API_KEY in .env file or environment variables
-- Python dependencies installed (pip install -e .)
+    - OPENAI_API_KEY in .env file or environment variables
+    - Python dependencies: pip install -r requirements.txt
 
 Usage:
     python run_baseline.py
 
 Output:
-- STDOUT: Real-time logging in competition format
-- baseline/baseline_results.json: Detailed results and statistics
+    - STDOUT: Real-time logging per step and per task
+    - baseline/baseline_results.json: Full results and statistics
 """
 
 import asyncio
@@ -25,11 +25,15 @@ from dotenv import load_dotenv
 # Load environment variables from .env file
 load_dotenv()
 
-# Add project root to path
+# Fail fast if API key missing
+if not os.getenv("OPENAI_API_KEY"):
+    print("ERROR: OPENAI_API_KEY not set. Add it to .env or environment variables.")
+    sys.exit(1)
+
+# Add project root to path so env/ and baseline/ are importable
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from baseline.run_baseline import main
 
 if __name__ == "__main__":
-    asyncio.run(main())
     asyncio.run(main())