Fix port overflow error in action execution server

.devcontainer/README.md

@@ -1 +0,0 @@
-This way of running OpenHands is not officially supported. It is maintained by the community.

.devcontainer/devcontainer.json

@@ -1,19 +0,0 @@
-// For format details, see: https://aka.ms/devcontainer.json
-{
-	"name": "Python 3",
-	// Documentation for this image:
-	// - https://github.com/devcontainers/templates/tree/main/src/python
-	// - https://github.com/microsoft/vscode-remote-try-python
-	// - https://hub.docker.com/r/microsoft/devcontainers-python
-	"image": "mcr.microsoft.com/devcontainers/python:1-3.12-bullseye",
-	"features": {
-		"ghcr.io/devcontainers/features/docker-outside-of-docker:1": {},
-		"ghcr.io/devcontainers-extra/features/poetry:2": {},
-		"ghcr.io/devcontainers/features/node:1": {},
-	},
-	"postCreateCommand": ".devcontainer/setup.sh",
-	"runArgs": ["--add-host=host.docker.internal:host-gateway"],
-	"containerEnv": {
-		"DOCKER_HOST_ADDR": "host.docker.internal"
-	},
-}

.devcontainer/setup.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-# Mark the current repository as safe for Git to prevent "dubious ownership" errors,
-# which can occur in containerized environments when directory ownership doesn't match the current user.
-git config --global --add safe.directory "$(realpath .)"
-
-# Install `nc`
-sudo apt update && sudo apt install netcat -y
-
-# Install `uv` and `uvx`
-wget -qO- https://astral.sh/uv/install.sh | sh
-
-# Do common setup tasks
-source .openhands/setup.sh

.dockerignore

@@ -1,23 +0,0 @@
-# NodeJS
-frontend/node_modules
-
-# Configuration (except pyproject.toml)
-*.ini
-*.toml
-!pyproject.toml
-*.yml
-
-# Documentation (except README.md)
-*.md
-!README.md
-
-# Hidden files and directories
-.*
-__pycache__
-
-# Unneded files and directories
-/dev_config/
-/docs/
-/evaluation/
-/tests/
-CITATION.cff

.editorconfig

@@ -1,5 +0,0 @@
-[*]
-# force *nix line endings so files don't look modified in container run from Windows clone
-end_of_line = lf
-trim_trailing_whitespace = true
-insert_final_newline = true

.gitattributes

@@ -1,7 +0,0 @@
-*.ipynb linguist-vendored
-
-# force *nix line endings so files don't look modified in container run from Windows clone
-* text eol=lf
-# Git incorrectly thinks some media is text
-*.png -text
-*.mp4 -text

.github/CODEOWNERS

@@ -1,8 +0,0 @@
-# CODEOWNERS file for OpenHands repository
-# See https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
-
-/frontend/ @amanape @hieptl
-/openhands-ui/ @amanape @hieptl
-/openhands/ @tofarr @malhotra5 @hieptl
-/enterprise/ @chuckbutkus @tofarr @malhotra5
-/evaluation/ @xingyaoww @neubig

.github/ISSUE_TEMPLATE/bug_template.yml

@@ -1,166 +0,0 @@
-name: Bug
-description: Report a problem with OpenHands
-title: '[Bug]: '
-labels: ['bug']
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## Thank you for reporting a bug! 🐛
-
-        **Please fill out all required fields.** Issues missing critical information (version, installation method, reproduction steps, etc.) will be delayed or closed until complete details are provided.
-
-        Clear, detailed reports help us resolve issues faster.
-
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for the same bug?
-      description: Please search existing issues before creating a new one. If found, react or comment to the duplicate issue instead of making a new one.
-      options:
-      - label: I have searched existing issues and this is not a duplicate.
-        required: true
-
-  - type: textarea
-    id: bug-description
-    attributes:
-      label: Bug Description
-      description: Clearly describe what went wrong. Be specific and concise.
-      placeholder: Example - "When I run a Python task, OpenHands crashes after 30 seconds with a connection timeout error."
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: Expected Behavior
-      description: What did you expect to happen?
-      placeholder: Example - "OpenHands should execute the Python script and return results."
-    validations:
-      required: false
-
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: Actual Behavior
-      description: What actually happened?
-      placeholder: Example - "Connection timed out after 30 seconds, task failed with error code 500."
-    validations:
-      required: false
-
-  - type: textarea
-    id: reproduction-steps
-    attributes:
-      label: Steps to Reproduce
-      description: Provide clear, step-by-step instructions to reproduce the bug.
-      placeholder: |
-        1. Install OpenHands using Docker
-        2. Configure with Claude 3.5 Sonnet
-        3. Run command: `openhands run "write a python script"`
-        4. Wait 30 seconds
-        5. Error appears
-    validations:
-      required: false
-
-  - type: dropdown
-    id: installation
-    attributes:
-      label: OpenHands Installation Method
-      description: How are you running OpenHands?
-      options:
-        - CLI (uv tool install)
-        - CLI (executable binary)
-        - CLI (Docker)
-        - Local GUI (Docker web interface)
-        - OpenHands Cloud (app.all-hands.dev)
-        - SDK (Python library)
-        - Development workflow
-        - Other
-      default: 0
-    validations:
-      required: false
-
-  - type: input
-    id: installation-other
-    attributes:
-      label: If you selected "Other", please specify
-      description: Describe your installation method
-      placeholder: ex. Custom Kubernetes deployment, pip install from source, etc.
-
-  - type: input
-    id: openhands-version
-    attributes:
-      label: OpenHands Version
-      description: What version are you using? Find this in settings or by running `openhands --version`
-      placeholder: ex. 0.9.8, main, commit hash, etc.
-    validations:
-      required: false
-
-  - type: checkboxes
-    id: version-confirmation
-    attributes:
-      label: Version Confirmation
-      description: Bugs on older versions may already be fixed. Please upgrade before submitting.
-      options:
-        - label: "I have confirmed this bug exists on the LATEST version of OpenHands"
-          required: false
-
-  - type: input
-    id: model-name
-    attributes:
-      label: Model Name
-      description: Which LLM model are you using?
-      placeholder: ex. gpt-4o, claude-3-5-sonnet-20241022, openrouter/deepseek-r1, etc.
-    validations:
-      required: false
-
-  - type: dropdown
-    id: os
-    attributes:
-      label: Operating System
-      options:
-        - MacOS
-        - Linux
-        - WSL on Windows
-        - Windows (Docker Desktop)
-        - Other
-    validations:
-      required: false
-
-  - type: input
-    id: browser
-    attributes:
-      label: Browser (if using web UI)
-      description: |
-        If applicable, which browser and version?
-
-      placeholder: ex. Chrome 131, Firefox 133, Safari 17.2
-
-  - type: textarea
-    id: logs
-    attributes:
-      label: Logs and Error Messages
-      description: |
-        **Paste relevant logs, error messages, or stack traces.** Use code blocks (```) for formatting.
-
-        LLM logs are in `logs/llm/default/`. Include timestamps if errors occurred at a specific time.
-      placeholder: |
-        ```
-        Paste error logs here
-        ```
-
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Screenshots and Additional Context
-      description: |
-        Add screenshots, videos, runtime environment, or other context that helps explain the issue.
-
-        💡 **Share conversation history:** In the OpenHands chat UI, click the 👎 or 👍 button (above the message input) to generate a shareable link to your conversation.
-
-      placeholder: Drag and drop screenshots here, paste links, or add additional context.
-
-  - type: markdown
-    attributes:
-      value: |
-        ---
-        **Note:** Issues with incomplete information may be closed or deprioritized. Maintainers and community members have limited bandwidth and prioritize well-documented bugs that are easier to reproduce and fix. Thank you for your understanding!

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,105 +0,0 @@
-name: Feature Request or Enhancement
-description: Suggest a new feature or improvement for OpenHands
-title: '[Feature]: '
-labels: ['enhancement']
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## Thank you for suggesting a feature! 💡
-
-        **Please provide detailed information.** Vague or low-effort requests may be closed. Well-documented feature requests with strong community support are more likely to be added to the roadmap.
-
-  - type: checkboxes
-    attributes:
-      label: Is there an existing feature request for this?
-      description: Please search existing issues and feature requests before creating a new one. If found, react or comment to the duplicate issue instead of making a new one.
-      options:
-      - label: I have searched existing issues and feature requests, and this is not a duplicate.
-        required: true
-
-  - type: textarea
-    id: problem-statement
-    attributes:
-      label: Problem or Use Case
-      description: What problem are you trying to solve? What use case would this feature enable?
-      placeholder: |
-        Example - "As a developer working on large codebases, I need to search across multiple files simultaneously. Currently, I have to search file-by-file which is time-consuming and inefficient."
-    validations:
-      required: true
-
-  - type: textarea
-    id: proposed-solution
-    attributes:
-      label: Proposed Solution
-      description: Describe your ideal solution. What should this feature do? How should it work?
-      placeholder: |
-        Example - "Add a global search feature that allows searching across all files in the workspace. Results should show file name, line number, and context around matches. Include regex support and filtering options."
-    validations:
-      required: true
-
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Alternatives Considered
-      description: Have you considered any alternative solutions or workarounds? What are their limitations?
-      placeholder: Example - "I tried using grep in the terminal, but it's not integrated with the UI and doesn't provide click-to-navigate functionality."
-
-  - type: dropdown
-    id: priority
-    attributes:
-      label: Priority / Severity
-      description: How important is this feature to your workflow?
-      options:
-        - "Critical - Blocking my work, no workaround available"
-        - "High - Significant impact on productivity"
-        - "Medium - Would improve experience"
-        - "Low - Nice to have"
-      default: 2
-    validations:
-      required: true
-
-  - type: dropdown
-    id: scope
-    attributes:
-      label: Estimated Scope
-      description: To the best of your knowledge, how complex do you think this feature would be to implement?
-      options:
-        - "Small - UI tweak, config option, or minor change"
-        - "Medium - New feature with moderate complexity"
-        - "Large - Significant feature requiring architecture changes"
-        - "Unknown - Not sure about the technical complexity"
-      default: 3
-
-  - type: dropdown
-    id: feature-area
-    attributes:
-      label: Feature Area
-      description: Which part of OpenHands does this feature relate to? If you select "Other", please specify the area in the Additional Context section below.
-      options:
-        - "Agent / AI behavior"
-        - "User Interface / UX"
-        - "CLI / Command-line interface"
-        - "File system / Workspace management"
-        - "Configuration / Settings"
-        - "Integrations (GitHub, GitLab, etc.)"
-        - "Performance / Optimization"
-        - "Documentation"
-        - "Other"
-    validations:
-      required: true
-
-  - type: textarea
-    id: technical-details
-    attributes:
-      label: Technical Implementation Ideas (Optional)
-      description: If you have technical expertise, share implementation ideas, API suggestions, or relevant technical details.
-      placeholder: |
-        Example - "Could use ripgrep library for fast search. Expose results via /api/search endpoint. Frontend can use virtualized list for rendering large result sets."
-
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: Add any other context, screenshots, mockups, or examples that help illustrate this feature request.
-      placeholder: Drag and drop screenshots, mockups, or links here.

.github/dependabot.yml

@@ -1,80 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "pip"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    open-pull-requests-limit: 1
-    groups:
-      # put packages in their own group if they have a history of breaking the build or needing to be reverted
-      pre-commit:
-        patterns:
-          - "pre-commit"
-      browsergym:
-        patterns:
-          - "browsergym*"
-      mcp-packages:
-        patterns:
-          - "mcp"
-      security-all:
-        applies-to: "security-updates"
-        patterns:
-          - "*"
-      version-all:
-        applies-to: "version-updates"
-        patterns:
-          - "*"
-
-  - package-ecosystem: "npm"
-    directory: "/frontend"
-    schedule:
-      interval: "daily"
-    open-pull-requests-limit: 1
-    groups:
-      docusaurus:
-        patterns:
-          - "*docusaurus*"
-      eslint:
-        patterns:
-          - "*eslint*"
-      security-all:
-        applies-to: "security-updates"
-        patterns:
-          - "*"
-      version-all:
-        applies-to: "version-updates"
-        patterns:
-          - "*"
-
-  - package-ecosystem: "npm"
-    directory: "/docs"
-    schedule:
-      interval: "weekly"
-      day: "wednesday"
-    open-pull-requests-limit: 1
-    groups:
-      docusaurus:
-        patterns:
-          - "*docusaurus*"
-      eslint:
-        patterns:
-          - "*eslint*"
-      security-all:
-        applies-to: "security-updates"
-        patterns:
-          - "*"
-      version-all:
-        applies-to: "version-updates"
-        patterns:
-          - "*"
-
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "docker"
-    directories:
-      - "containers/*"
-    schedule:
-      interval: "weekly"

.github/pull_request_template.md

@@ -1,38 +0,0 @@
-<!-- If you are still working on the PR, please mark it as draft. Maintainers will review PRs marked ready for review, which leads to lost time if your PR is actually not ready yet. Keep the PR marked as draft until it is finally ready for review -->
-
-## Summary of PR
-
-<!-- Summarize what the PR does -->
-
-## Demo Screenshots/Videos
-
-<!-- AI/LLM AGENTS: This section is intended for a human author to add screenshots or videos demonstrating the PR in action (optional). While many pull requests may be generated by AI/LLM agents, we are fine with this as long as a human author has reviewed and tested the changes to ensure accuracy and functionality. -->
-
-## Change Type
-
-<!-- Choose the types that apply to your PR -->
-
-- [ ] Bug fix
-- [ ] New feature
-- [ ] Breaking change
-- [ ] Refactor
-- [ ] Other (dependency update, docs, typo fixes, etc.)
-
-## Checklist
-<!-- AI/LLM AGENTS: This checklist is for a human author to complete. Do NOT check either of the two boxes below. Leave them unchecked until a human has personally reviewed and tested the changes. -->
-
-- [ ] I have read and reviewed the code and I understand what the code is doing.
-- [ ] I have tested the code to the best of my ability and ensured it works as expected.
-
-## Fixes
-
-<!-- If this resolves an issue, link it here so it will close automatically upon merge. -->
-
-Resolves #(issue)
-
-## Release Notes
-
-<!-- Check the box if this change is worth adding to the release notes. If checked, you must provide an
-end-user friendly description for your change below the checkbox. -->
-
-- [ ] Include this change in the Release Notes.

.github/scripts/update_pr_description.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-# This script updates the PR description with commands to run the PR locally
-# It adds both Docker and uvx commands
-
-# Get the branch name for the PR
-BRANCH_NAME=$(gh pr view "$PR_NUMBER" --json headRefName --jq .headRefName)
-
-# Define the Docker command
-DOCKER_RUN_COMMAND="docker run -it --rm \
-  -p 3000:3000 \
-  -v /var/run/docker.sock:/var/run/docker.sock \
-  --add-host host.docker.internal:host-gateway \
-  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.openhands.dev/openhands/runtime:${SHORT_SHA}-nikolaik \
-  --name openhands-app-${SHORT_SHA} \
-  docker.openhands.dev/openhands/openhands:${SHORT_SHA}"
-
-# Get the current PR body
-PR_BODY=$(gh pr view "$PR_NUMBER" --json body --jq .body)
-
-# Prepare the new PR body with both commands
-if echo "$PR_BODY" | grep -q "To run this PR locally, use the following command:"; then
-  # For existing PR descriptions, use a more robust approach
-  # Split the PR body at the "To run this PR locally" section and replace everything after it
-  BEFORE_SECTION=$(echo "$PR_BODY" | sed '/To run this PR locally, use the following command:/,$d')
-  NEW_PR_BODY=$(cat <<EOF
-${BEFORE_SECTION}
-
-To run this PR locally, use the following command:
-
-GUI with Docker:
-\`\`\`
-${DOCKER_RUN_COMMAND}
-\`\`\`
-EOF
-)
-else
-  # For new PR descriptions: use heredoc safely without indentation
-  NEW_PR_BODY=$(cat <<EOF
-$PR_BODY
-
----
-
-To run this PR locally, use the following command:
-
-GUI with Docker:
-\`\`\`
-${DOCKER_RUN_COMMAND}
-\`\`\`
-EOF
-)
-fi
-
-# Update the PR description
-echo "Updating PR description with Docker and uvx commands"
-gh pr edit "$PR_NUMBER" --body "$NEW_PR_BODY"

.github/workflows/check-package-versions.yml

@@ -1,65 +0,0 @@
-name: Check Package Versions
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-  workflow_dispatch:
-
-jobs:
-  check-package-versions:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: "3.12"
-
-      - name: Check for any 'rev' fields in pyproject.toml
-        run: |
-          python - <<'PY'
-          import sys, tomllib, pathlib
-
-          path = pathlib.Path("pyproject.toml")
-          if not path.exists():
-              print("❌ ERROR: pyproject.toml not found")
-              sys.exit(1)
-
-          try:
-              data = tomllib.loads(path.read_text(encoding="utf-8"))
-          except Exception as e:
-              print(f"❌ ERROR: Failed to parse pyproject.toml: {e}")
-              sys.exit(1)
-
-          poetry = data.get("tool", {}).get("poetry", {})
-          sections = {
-              "dependencies": poetry.get("dependencies", {}),
-          }
-
-          errors = []
-
-          print("🔍 Checking for any dependencies with 'rev' fields...\n")
-          for section_name, deps in sections.items():
-              if not isinstance(deps, dict):
-                  continue
-
-              for pkg_name, cfg in deps.items():
-                  if isinstance(cfg, dict) and "rev" in cfg:
-                      msg = f"  ✖ {pkg_name} in [{section_name}] uses rev='{cfg['rev']}' (NOT ALLOWED)"
-                      print(msg)
-                      errors.append(msg)
-                  else:
-                      print(f"  • {pkg_name}: OK")
-
-          if errors:
-              print("\n❌ FAILED: Found dependencies using 'rev' fields:\n" + "\n".join(errors))
-              print("\nPlease use versioned releases instead, e.g.:")
-              print('  my-package = "1.0.0"')
-              sys.exit(1)
-
-          print("\n✅ SUCCESS: No 'rev' fields found. All dependencies are using proper versioned releases.")
-          PY

.github/workflows/e2e-tests.yml

@@ -1,228 +0,0 @@
-name: End-to-End Tests
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened, labeled]
-    branches:
-      - main
-      - develop
-  workflow_dispatch:
-
-jobs:
-  e2e-tests:
-    if: contains(github.event.pull_request.labels.*.name, 'end-to-end') || github.event_name == 'workflow_dispatch'
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-
-    env:
-      GITHUB_REPO_NAME: ${{ github.repository }}
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install poetry via pipx
-        uses: abatilo/actions-poetry@v4
-        with:
-          poetry-version: 2.1.3
-
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.12'
-          cache: 'poetry'
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-0 libnotify4 libnss3 libxss1 libxtst6 xauth xvfb libgbm1 libasound2t64 netcat-openbsd
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: '22'
-          cache: 'npm'
-          cache-dependency-path: 'frontend/package-lock.json'
-
-      - name: Setup environment for end-to-end tests
-        run: |
-          # Create test results directory
-          mkdir -p test-results
-
-          # Create downloads directory for OpenHands (use a directory in the home folder)
-          mkdir -p $HOME/downloads
-          sudo chown -R $USER:$USER $HOME/downloads
-          sudo chmod -R 755 $HOME/downloads
-
-      - name: Build OpenHands
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          LLM_MODEL: ${{ secrets.LLM_MODEL || 'gpt-4o' }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY || 'test-key' }}
-          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-          INSTALL_DOCKER: 1
-          RUNTIME: docker
-          FRONTEND_PORT: 12000
-          FRONTEND_HOST: 0.0.0.0
-          BACKEND_HOST: 0.0.0.0
-          BACKEND_PORT: 3000
-          ENABLE_BROWSER: true
-          INSTALL_PLAYWRIGHT: 1
-        run: |
-          # Fix poetry.lock file if needed
-          echo "Fixing poetry.lock file if needed..."
-          poetry lock
-
-          # Build OpenHands using make build
-          echo "Running make build..."
-          make build
-
-          # Install Chromium Headless Shell for Playwright (needed for pytest-playwright)
-          echo "Installing Chromium Headless Shell for Playwright..."
-          poetry run playwright install chromium-headless-shell
-
-          # Verify Playwright browsers are installed (for e2e tests only)
-          echo "Verifying Playwright browsers installation for e2e tests..."
-          BROWSER_CHECK=$(poetry run python tests/e2e/check_playwright.py 2>/dev/null)
-
-          if [ "$BROWSER_CHECK" != "chromium_found" ]; then
-            echo "ERROR: Chromium browser not found or not working for e2e tests"
-            echo "$BROWSER_CHECK"
-            exit 1
-          else
-            echo "Playwright browsers are properly installed for e2e tests."
-          fi
-
-          # Docker runtime will handle workspace directory creation
-
-          # Start the application using make run with custom parameters and reduced logging
-          echo "Starting OpenHands using make run..."
-          # Set environment variables to reduce logging verbosity
-          export PYTHONUNBUFFERED=1
-          export LOG_LEVEL=WARNING
-          export UVICORN_LOG_LEVEL=warning
-          export OPENHANDS_LOG_LEVEL=WARNING
-          FRONTEND_PORT=12000 FRONTEND_HOST=0.0.0.0 BACKEND_HOST=0.0.0.0 make run > /tmp/openhands-e2e-test.log 2>&1 &
-
-          # Store the PID of the make run process
-          MAKE_PID=$!
-          echo "OpenHands started with PID: $MAKE_PID"
-
-          # Wait for the application to start
-          echo "Waiting for OpenHands to start..."
-          max_attempts=15
-          attempt=1
-
-          while [ $attempt -le $max_attempts ]; do
-            echo "Checking if OpenHands is running (attempt $attempt of $max_attempts)..."
-
-            # Check if the process is still running
-            if ! ps -p $MAKE_PID > /dev/null; then
-              echo "ERROR: OpenHands process has terminated unexpectedly"
-              echo "Last 50 lines of the log:"
-              tail -n 50 /tmp/openhands-e2e-test.log
-              exit 1
-            fi
-
-            # Check if frontend port is open
-            if nc -z localhost 12000; then
-              # Verify we can get HTML content
-              if curl -s http://localhost:12000 | grep -q "<html"; then
-                echo "SUCCESS: OpenHands is running and serving HTML content on port 12000"
-                break
-              else
-                echo "Port 12000 is open but not serving HTML content yet"
-              fi
-            else
-              echo "Frontend port 12000 is not open yet"
-            fi
-
-            # Show log output on each attempt
-            echo "Recent log output:"
-            tail -n 20 /tmp/openhands-e2e-test.log
-
-            # Wait before next attempt
-            echo "Waiting 10 seconds before next check..."
-            sleep 10
-            attempt=$((attempt + 1))
-
-            # Exit if we've reached the maximum number of attempts
-            if [ $attempt -gt $max_attempts ]; then
-              echo "ERROR: OpenHands failed to start after $max_attempts attempts"
-              echo "Last 50 lines of the log:"
-              tail -n 50 /tmp/openhands-e2e-test.log
-              exit 1
-            fi
-          done
-
-          # Final verification that the app is running
-          if ! nc -z localhost 12000 || ! curl -s http://localhost:12000 | grep -q "<html"; then
-            echo "ERROR: OpenHands is not running properly on port 12000"
-            echo "Last 50 lines of the log:"
-            tail -n 50 /tmp/openhands-e2e-test.log
-            exit 1
-          fi
-
-          # Print success message
-          echo "OpenHands is running successfully on port 12000"
-
-      - name: Run end-to-end tests
-        env:
-          GITHUB_TOKEN: ${{ secrets.E2E_TEST_GITHUB_TOKEN }}
-          LLM_MODEL: ${{ secrets.LLM_MODEL || 'gpt-4o' }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY || 'test-key' }}
-          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-        run: |
-          # Check if the application is running
-          if ! nc -z localhost 12000; then
-            echo "ERROR: OpenHands is not running on port 12000"
-            echo "Last 50 lines of the log:"
-            tail -n 50 /tmp/openhands-e2e-test.log
-            exit 1
-          fi
-
-          # Run the tests with detailed output
-          cd tests/e2e
-          poetry run python -m pytest \
-            test_settings.py::test_github_token_configuration \
-            test_conversation.py::test_conversation_start \
-            test_browsing_catchphrase.py::test_browsing_catchphrase \
-            test_multi_conversation_resume.py::test_multi_conversation_resume \
-            -v --no-header --capture=no --timeout=900
-
-      - name: Upload test results
-        if: always()
-        uses: actions/upload-artifact@v6
-        with:
-          name: playwright-report
-          path: tests/e2e/test-results/
-          retention-days: 30
-
-      - name: Upload OpenHands logs
-        if: always()
-        uses: actions/upload-artifact@v6
-        with:
-          name: openhands-logs
-          path: |
-            /tmp/openhands-e2e-test.log
-            /tmp/openhands-e2e-build.log
-            /tmp/openhands-backend.log
-            /tmp/openhands-frontend.log
-            /tmp/backend-health-check.log
-            /tmp/frontend-check.log
-            /tmp/vite-config.log
-            /tmp/makefile-contents.log
-          retention-days: 30
-
-      - name: Cleanup
-        if: always()
-        run: |
-          # Stop OpenHands processes
-          echo "Stopping OpenHands processes..."
-          pkill -f "python -m openhands.server" || true
-          pkill -f "npm run dev" || true
-          pkill -f "make run" || true
-
-          # Print process status for debugging
-          echo "Checking if any OpenHands processes are still running:"
-          ps aux | grep -E "openhands|npm run dev" || true

.github/workflows/enterprise-check-migrations.yml

@@ -1,52 +0,0 @@
-name: Enterprise Check Migrations
-
-on:
-  pull_request:
-    paths:
-      - 'enterprise/migrations/**'
-
-jobs:
-  check-sync:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout PR branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          fetch-depth: 0
-
-
-      - name: Fetch base branch
-        run: git fetch origin ${{ github.event.pull_request.base.ref }}
-
-      - name: Check if base branch is ancestor of PR
-        id: check_up_to_date
-        shell: bash
-        run: |
-          BASE="origin/${{ github.event.pull_request.base.ref }}"
-          HEAD="${{ github.event.pull_request.head.sha }}"
-          if git merge-base --is-ancestor "$BASE" "$HEAD"; then
-            echo "We're up to date with base $BASE"
-            exit 0
-          else
-            echo "NOT up to date with base $BASE"
-            exit 1
-          fi
-
-      - name: Find Comment
-        uses: peter-evans/find-comment@v3
-        id: find-comment
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-author: 'github-actions[bot]'
-          body-includes: |
-            ⚠️ This PR contains **migrations**
-
-      - name: Comment warning on PR
-        uses: peter-evans/create-or-update-comment@v5
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          body: |
-            ⚠️ This PR contains **migrations**. Please synchronize before merging to prevent conflicts.

.github/workflows/enterprise-preview.yml

@@ -1,29 +0,0 @@
-# Feature branch preview for enterprise code
-name: Enterprise Preview
-
-# Run on PRs labeled
-on:
-  pull_request:
-    types: [labeled]
-
-# Match ghcr-build.yml, but don't interrupt it.
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: false
-
-jobs:
-  # This must happen for the PR Docker workflow when the label is present,
-  # and also if it's added after the fact. Thus, it exists in both places.
-  enterprise-preview:
-    name: Enterprise preview
-    if: github.event.label.name == 'deploy'
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      # This should match the version in ghcr-build.yml
-      - name: Trigger remote job
-        run: |
-          curl --fail-with-body -sS -X POST \
-            -H "Authorization: Bearer ${{ secrets.ALLHANDS_BOT_GITHUB_PAT }}" \
-            -H "Accept: application/vnd.github+json" \
-            -d "{\"ref\": \"main\", \"inputs\": {\"openhandsPrNumber\": \"${{ github.event.pull_request.number }}\", \"deployEnvironment\": \"feature\", \"enterpriseImageTag\": \"pr-${{ github.event.pull_request.number }}\" }}" \
-            https://api.github.com/repos/OpenHands/deploy/actions/workflows/deploy.yaml/dispatches

.github/workflows/fe-e2e-tests.yml

@@ -1,47 +0,0 @@
-# Workflow that runs frontend e2e tests with Playwright
-name: Run Frontend E2E Tests
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    paths:
-      - "frontend/**"
-      - ".github/workflows/fe-e2e-tests.yml"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  fe-e2e-test:
-    name: FE E2E Tests
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    strategy:
-      matrix:
-        node-version: [22]
-      fail-fast: true
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Node.js
-        uses: useblacksmith/setup-node@v5
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install dependencies
-        working-directory: ./frontend
-        run: npm ci
-      - name: Install Playwright browsers
-        working-directory: ./frontend
-        run: npx playwright install --with-deps chromium
-      - name: Run Playwright tests
-        working-directory: ./frontend
-        run: npx playwright test --project=chromium
-      - name: Upload Playwright report
-        uses: actions/upload-artifact@v6
-        if: always()
-        with:
-          name: playwright-report
-          path: frontend/playwright-report/
-          retention-days: 30

.github/workflows/fe-unit-tests.yml

@@ -1,44 +0,0 @@
-# Workflow that runs frontend unit tests
-name: Run Frontend Unit Tests
-
-# * Always run on "main"
-# * Run on PRs that have changes in the "frontend" folder or this workflow
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    paths:
-      - "frontend/**"
-      - ".github/workflows/fe-unit-tests.yml"
-
-# If triggered by a PR, it will be in the same group. However, each commit on main will be in its own unique group
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  # Run frontend unit tests
-  fe-test:
-    name: FE Unit Tests
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    strategy:
-      matrix:
-        node-version: [22]
-      fail-fast: true
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Node.js
-        uses: useblacksmith/setup-node@v5
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install dependencies
-        working-directory: ./frontend
-        run: npm ci
-      - name: Run TypeScript compilation
-        working-directory: ./frontend
-        run: npm run build
-      - name: Run tests and collect coverage
-        working-directory: ./frontend
-        run: npm run test:coverage

.github/workflows/ghcr-build.yml

@@ -1,288 +0,0 @@
-# Workflow that builds, tests and then pushes the OpenHands and runtime docker images to the ghcr.io repository
-name: Docker
-
-# Always run on "main"
-# Always run on tags
-# Always run on PRs
-# Can also be triggered manually
-on:
-  push:
-    branches:
-      - main
-    tags:
-      - "*"
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      reason:
-        description: "Reason for manual trigger"
-        required: true
-        default: ""
-
-# If triggered by a PR, it will be in the same group. However, each commit on main will be in its own unique group
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  RELEVANT_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
-
-jobs:
-  define-matrix:
-    runs-on: blacksmith
-    outputs:
-      base_image: ${{ steps.define-base-images.outputs.base_image }}
-    steps:
-      - name: Define base images
-        shell: bash
-        id: define-base-images
-        run: |
-          if [[ "$GITHUB_EVENT_NAME" == "pull_request" ]]; then
-            json=$(jq -n -c '[
-                { image: "nikolaik/python-nodejs:python3.12-nodejs22", tag: "nikolaik" }
-              ]')
-          else
-            json=$(jq -n -c '[
-                { image: "nikolaik/python-nodejs:python3.12-nodejs22", tag: "nikolaik" },
-                { image: "ubuntu:24.04", tag: "ubuntu" }
-              ]')
-          fi
-          echo "base_image=$json" >> "$GITHUB_OUTPUT"
-
-  # Builds the OpenHands Docker images
-  ghcr_build_app:
-    name: Build App Image
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    if: "!(github.event_name == 'push' && startsWith(github.ref, 'refs/tags/ext-v'))"
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.7.0
-        with:
-          image: tonistiigi/binfmt:latest
-      - name: Login to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Lowercase Repository Owner
-        run: |
-          echo REPO_OWNER=$(echo ${{ github.repository_owner }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
-      - name: Build and push app image
-        if: "!github.event.pull_request.head.repo.fork"
-        run: |
-          ./containers/build.sh -i openhands -o ${{ env.REPO_OWNER }} --push
-
-  # Builds the runtime Docker images
-  ghcr_build_runtime:
-    name: Build Runtime Image
-    runs-on: blacksmith-8vcpu-ubuntu-2204
-    if: "!(github.event_name == 'push' && startsWith(github.ref, 'refs/tags/ext-v'))"
-    permissions:
-      contents: read
-      packages: write
-    needs: define-matrix
-    strategy:
-      matrix:
-        base_image: ${{ fromJson(needs.define-matrix.outputs.base_image) }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.7.0
-        with:
-          image: tonistiigi/binfmt:latest
-      - name: Login to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Install poetry via pipx
-        run: pipx install poetry
-      - name: Set up Python
-        uses: useblacksmith/setup-python@v6
-        with:
-          python-version: "3.12"
-          cache: poetry
-      - name: Install Python dependencies using Poetry
-        run: make install-python-dependencies POETRY_GROUP=main INSTALL_PLAYWRIGHT=0
-      - name: Create source distribution and Dockerfile
-        run: poetry run python3 -m openhands.runtime.utils.runtime_build --base_image ${{ matrix.base_image.image }} --build_folder containers/runtime --force_rebuild
-      - name: Lowercase Repository Owner
-        run: |
-          echo REPO_OWNER=$(echo ${{ github.repository_owner }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
-      - name: Short SHA
-        run: |
-          echo SHORT_SHA=$(git rev-parse --short "$RELEVANT_SHA") >> $GITHUB_ENV
-      - name: Determine docker build params
-        if: github.event.pull_request.head.repo.fork != true
-        shell: bash
-        run: |
-
-          ./containers/build.sh -i runtime -o ${{ env.REPO_OWNER }} -t ${{ matrix.base_image.tag }} --dry
-
-          DOCKER_BUILD_JSON=$(jq -c . < docker-build-dry.json)
-          echo "DOCKER_TAGS=$(echo "$DOCKER_BUILD_JSON" | jq -r '.tags | join(",")')" >> $GITHUB_ENV
-          echo "DOCKER_PLATFORM=$(echo "$DOCKER_BUILD_JSON" | jq -r '.platform')" >> $GITHUB_ENV
-          echo "DOCKER_BUILD_ARGS=$(echo "$DOCKER_BUILD_JSON" | jq -r '.build_args | join(",")')" >> $GITHUB_ENV
-      - name: Build and push runtime image ${{ matrix.base_image.image }}
-        if: github.event.pull_request.head.repo.fork != true
-        uses: useblacksmith/build-push-action@v1
-        with:
-          push: true
-          tags: ${{ env.DOCKER_TAGS }}
-          platforms: ${{ env.DOCKER_PLATFORM }}
-          # Caching directives to boost performance
-          cache-from: type=registry,ref=ghcr.io/${{ env.REPO_OWNER }}/runtime:buildcache-${{ matrix.base_image.tag }}
-          cache-to: type=registry,ref=ghcr.io/${{ env.REPO_OWNER }}/runtime:buildcache-${{ matrix.base_image.tag }},mode=max
-          build-args: ${{ env.DOCKER_BUILD_ARGS }}
-          context: containers/runtime
-          provenance: false
-      # Forked repos can't push to GHCR, so we just build in order to populate the cache for rebuilding
-      - name: Build runtime image ${{ matrix.base_image.image }} for fork
-        if: github.event.pull_request.head.repo.fork
-        uses: useblacksmith/build-push-action@v1
-        with:
-          tags: ghcr.io/${{ env.REPO_OWNER }}/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image.tag }}
-          context: containers/runtime
-      - name: Upload runtime source for fork
-        if: github.event.pull_request.head.repo.fork
-        uses: actions/upload-artifact@v6
-        with:
-          name: runtime-src-${{ matrix.base_image.tag }}
-          path: containers/runtime
-
-  ghcr_build_enterprise:
-    name: Push Enterprise Image
-    runs-on: blacksmith-8vcpu-ubuntu-2204
-    permissions:
-      contents: read
-      packages: write
-    needs: [define-matrix, ghcr_build_app]
-    # Do not build enterprise in forks
-    if: github.event.pull_request.head.repo.fork != true
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-
-      # Set up Docker Buildx for better performance
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver-opts: network=host
-
-      - name: Login to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ghcr.io/openhands/enterprise-server
-          tags: |
-            type=ref,event=branch
-            type=ref,event=pr
-            type=sha
-            type=sha,format=long
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=semver,pattern={{major}}
-          flavor: |
-            latest=auto
-            prefix=
-            suffix=
-        env:
-          DOCKER_METADATA_PR_HEAD_SHA: true
-      - name: Determine app image tag
-        shell: bash
-        run: |
-          # Duplicated with build.sh
-          sanitized_ref_name=$(echo "$GITHUB_REF_NAME" | sed 's/[^a-zA-Z0-9.-]\+/-/g')
-          OPENHANDS_BUILD_VERSION=$sanitized_ref_name
-          sanitized_ref_name=$(echo "$sanitized_ref_name" | tr '[:upper:]' '[:lower:]') # lower case is required in tagging
-          echo "OPENHANDS_DOCKER_TAG=${sanitized_ref_name}" >> $GITHUB_ENV
-      - name: Build and push Docker image
-        uses: useblacksmith/build-push-action@v1
-        with:
-          context: .
-          file: enterprise/Dockerfile
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: |
-            OPENHANDS_VERSION=${{ env.OPENHANDS_DOCKER_TAG }}
-          platforms: linux/amd64
-          # Add build provenance
-          provenance: true
-          # Add build attestations for better security
-          sbom: true
-
-  enterprise-preview:
-    name: Enterprise preview
-    if: github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy')
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    needs: [ghcr_build_enterprise]
-    steps:
-      # This should match the version in enterprise-preview.yml
-      - name: Trigger remote job
-        run: |
-          curl --fail-with-body -sS -X POST \
-            -H "Authorization: Bearer ${{ secrets.ALLHANDS_BOT_GITHUB_PAT }}" \
-            -H "Accept: application/vnd.github+json" \
-            -d "{\"ref\": \"main\", \"inputs\": {\"openhandsPrNumber\": \"${{ github.event.pull_request.number }}\", \"deployEnvironment\": \"feature\", \"enterpriseImageTag\": \"pr-${{ github.event.pull_request.number }}\" }}" \
-            https://api.github.com/repos/OpenHands/deploy/actions/workflows/deploy.yaml/dispatches
-
-  # "All Runtime Tests Passed" is a required job for PRs to merge
-  # We can remove this once the config changes
-  runtime_tests_check_success:
-    name: All Runtime Tests Passed
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      - name: All tests passed
-        run: echo "All runtime tests have passed successfully!"
-
-  update_pr_description:
-    name: Update PR Description
-    if: github.event_name == 'pull_request' && !github.event.pull_request.head.repo.fork && github.actor != 'dependabot[bot]'
-    needs: [ghcr_build_runtime]
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Get short SHA
-        id: short_sha
-        run: echo "SHORT_SHA=$(echo ${{ github.event.pull_request.head.sha }} | cut -c1-7)" >> $GITHUB_OUTPUT
-
-      - name: Update PR Description
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REPO: ${{ github.repository }}
-          SHORT_SHA: ${{ steps.short_sha.outputs.SHORT_SHA }}
-        shell: bash
-        run: |
-          echo "Updating PR description with Docker and uvx commands"
-          bash ${GITHUB_WORKSPACE}/.github/scripts/update_pr_description.sh

.github/workflows/lint-fix.yml

@@ -1,97 +0,0 @@
-name: Lint Fix
-
-on:
-  pull_request:
-    types: [labeled]
-
-jobs:
-  # Frontend lint fixes
-  lint-fix-frontend:
-    if: github.event.label.name == 'lint-fix'
-    name: Fix frontend linting issues
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install Node.js 22
-        uses: useblacksmith/setup-node@v5
-        with:
-          node-version: 22
-      - name: Install frontend dependencies
-        run: |
-          cd frontend
-          npm install --frozen-lockfile
-      - name: Generate i18n and route types
-        run: |
-          cd frontend
-          npm run make-i18n
-          npx react-router typegen || true
-
-      - name: Fix frontend lint issues
-        run: |
-          cd frontend
-          npm run lint:fix
-
-      # Commit and push changes if any
-      - name: Check for changes
-        id: git-check
-        run: |
-          git diff --quiet || echo "changes=true" >> $GITHUB_OUTPUT
-      - name: Commit and push if there are changes
-        if: steps.git-check.outputs.changes == 'true'
-        run: |
-          git config --local user.email "openhands@all-hands.dev"
-          git config --local user.name "OpenHands Bot"
-          git add -A
-          git commit -m "🤖 Auto-fix frontend linting issues" --no-verify
-          git push
-
-  # Python lint fixes
-  lint-fix-python:
-    if: github.event.label.name == 'lint-fix'
-    name: Fix Python linting issues
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Set up python
-        uses: useblacksmith/setup-python@v6
-        with:
-          python-version: 3.12
-          cache: "pip"
-      - name: Install pre-commit
-        run: pip install pre-commit==3.7.0
-      - name: Fix python lint issues
-        run: |
-          # Run all pre-commit hooks and continue even if they modify files (exit code 1)
-          pre-commit run --config ./dev_config/python/.pre-commit-config.yaml --all-files || true
-
-      # Commit and push changes if any
-      - name: Check for changes
-        id: git-check
-        run: |
-          git diff --quiet || echo "changes=true" >> $GITHUB_OUTPUT
-      - name: Commit and push if there are changes
-        if: steps.git-check.outputs.changes == 'true'
-        run: |
-          git config --local user.email "openhands@all-hands.dev"
-          git config --local user.name "OpenHands Bot"
-          git add -A
-          git commit -m "🤖 Auto-fix Python linting issues" --no-verify
-          git push

.github/workflows/lint.yml

@@ -1,74 +0,0 @@
-# Workflow that runs lint on the frontend and python code
-name: Lint
-
-# The jobs in this workflow are required, so they must run at all times
-# Always run on "main"
-# Always run on PRs
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-
-# If triggered by a PR, it will be in the same group. However, each commit on main will be in its own unique group
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  # Run lint on the frontend code
-  lint-frontend:
-    name: Lint frontend
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install Node.js 22
-        uses: useblacksmith/setup-node@v5
-        with:
-          node-version: 22
-      - name: Install dependencies
-        run: |
-          cd frontend
-          npm install --frozen-lockfile
-      - name: Lint, TypeScript compilation, and translation checks
-        run: |
-          cd frontend
-          npm run lint
-          npm run make-i18n && tsc
-          npm run check-translation-completeness
-
-  # Run lint on the python code
-  lint-python:
-    name: Lint python
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up python
-        uses: useblacksmith/setup-python@v6
-        with:
-          python-version: 3.12
-          cache: "pip"
-      - name: Install pre-commit
-        run: pip install pre-commit==3.7.0
-      - name: Run pre-commit hooks
-        run: pre-commit run --all-files --show-diff-on-failure --config ./dev_config/python/.pre-commit-config.yaml
-
-  lint-enterprise-python:
-    name: Lint enterprise python
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up python
-        uses: useblacksmith/setup-python@v6
-        with:
-          python-version: 3.12
-          cache: "pip"
-      - name: Install pre-commit
-        run: pip install pre-commit==4.2.0
-      - name: Run pre-commit hooks
-        working-directory: ./enterprise
-        run: pre-commit run --all-files --show-diff-on-failure --config ./dev_config/python/.pre-commit-config.yaml

.github/workflows/npm-publish-ui.yml

@@ -1,108 +0,0 @@
-name: Publish OpenHands UI Package
-
-# * Always run on "main"
-# * Run on PRs that have changes in the "openhands-ui" folder or this workflow
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "openhands-ui/**"
-      - ".github/workflows/npm-publish-ui.yml"
-
-# If triggered by a PR, it will be in the same group. However, each commit on main will be in its own unique group
-concurrency:
-  group: npm-publish-ui
-  cancel-in-progress: false
-
-jobs:
-  check-version:
-    name: Check if version has changed
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    defaults:
-      run:
-        shell: bash
-    outputs:
-      should-publish: ${{ steps.version-check.outputs.should-publish }}
-      current-version: ${{ steps.version-check.outputs.current-version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 2 # Need previous commit to compare
-
-      - name: Check if version changed
-        id: version-check
-        run: |
-          # Get current version from package.json
-          CURRENT_VERSION=$(jq -r .version openhands-ui/package.json)
-          echo "current-version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
-
-          # Check if package.json version changed in this commit
-          if git diff HEAD~1 HEAD --name-only | grep -q "openhands-ui/package.json"; then
-            # Check if the version field specifically changed
-            if git diff HEAD~1 HEAD openhands-ui/package.json | grep -q '"version"'; then
-              echo "Version changed in package.json, will publish"
-              echo "should-publish=true" >> $GITHUB_OUTPUT
-            else
-              echo "package.json changed but version did not change, skipping publish"
-              echo "should-publish=false" >> $GITHUB_OUTPUT
-            fi
-          else
-            echo "package.json did not change, skipping publish"
-            echo "should-publish=false" >> $GITHUB_OUTPUT
-          fi
-
-  publish:
-    name: Publish to npm
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    needs: check-version
-    if: needs.check-version.outputs.should-publish == 'true'
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version-file: "openhands-ui/.bun-version"
-
-      - name: Install dependencies
-        working-directory: ./openhands-ui
-        run: bun install --frozen-lockfile
-
-      - name: Build package
-        working-directory: ./openhands-ui
-        run: bun run build
-
-      - name: Check if package already exists on npm
-        id: npm-check
-        working-directory: ./openhands-ui
-        run: |
-          PACKAGE_NAME=$(jq -r .name package.json)
-          VERSION="${{ needs.check-version.outputs.current-version }}"
-
-          # Check if this version already exists on npm
-          if npm view "$PACKAGE_NAME@$VERSION" version 2>/dev/null; then
-            echo "Version $VERSION already exists on npm, skipping publish"
-            echo "already-exists=true" >> $GITHUB_OUTPUT
-          else
-            echo "Version $VERSION does not exist on npm, proceeding with publish"
-            echo "already-exists=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Setup npm authentication
-        if: steps.npm-check.outputs.already-exists == 'false'
-        run: |
-          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > ~/.npmrc
-
-      - name: Publish to npm
-        if: steps.npm-check.outputs.already-exists == 'false'
-        working-directory: ./openhands-ui
-        run: |
-          # The prepublishOnly script will run automatically and build the package
-          npm publish
-          echo "✅ Successfully published @openhands/ui@${{ needs.check-version.outputs.current-version }} to npm"

.github/workflows/openhands-resolver.yml

@@ -1,433 +0,0 @@
-name: Auto-Fix Tagged Issue with OpenHands
-
-on:
-  workflow_call:
-    inputs:
-      max_iterations:
-        required: false
-        type: number
-        default: 50
-      macro:
-        required: false
-        type: string
-        default: "@openhands-agent"
-      target_branch:
-        required: false
-        type: string
-        default: "main"
-        description: "Target branch to pull and create PR against"
-      pr_type:
-        required: false
-        type: string
-        default: "draft"
-        description: "The PR type that is going to be created (draft, ready)"
-      LLM_MODEL:
-        required: false
-        type: string
-        default: "anthropic/claude-sonnet-4-20250514"
-      LLM_API_VERSION:
-        required: false
-        type: string
-        default: ""
-      base_container_image:
-        required: false
-        type: string
-        default: ""
-        description: "Custom sandbox env"
-      runner:
-        required: false
-        type: string
-        default: "ubuntu-latest"
-    secrets:
-      LLM_MODEL:
-        required: false
-      LLM_API_KEY:
-        required: true
-      LLM_BASE_URL:
-        required: false
-      PAT_TOKEN:
-        required: false
-      PAT_USERNAME:
-        required: false
-
-  issues:
-    types: [labeled]
-  pull_request:
-    types: [labeled]
-  issue_comment:
-    types: [created]
-  pull_request_review_comment:
-    types: [created]
-  pull_request_review:
-    types: [submitted]
-
-permissions:
-  contents: write
-  pull-requests: write
-  issues: write
-
-jobs:
-  auto-fix:
-    if: |
-      github.event_name == 'workflow_call' ||
-      github.event.label.name == 'fix-me' ||
-      github.event.label.name == 'fix-me-experimental' ||
-      (
-        ((github.event_name == 'issue_comment' || github.event_name == 'pull_request_review_comment') &&
-        contains(github.event.comment.body, inputs.macro || '@openhands-agent') &&
-        (github.event.comment.author_association == 'OWNER' || github.event.comment.author_association == 'COLLABORATOR' || github.event.comment.author_association == 'MEMBER')
-        ) ||
-
-        (github.event_name == 'pull_request_review' &&
-        contains(github.event.review.body, inputs.macro || '@openhands-agent') &&
-        (github.event.review.author_association == 'OWNER' || github.event.review.author_association == 'COLLABORATOR' || github.event.review.author_association == 'MEMBER')
-        )
-      )
-    runs-on: "${{ inputs.runner || 'ubuntu-latest' }}"
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: "3.12"
-      - name: Upgrade pip
-        run: |
-          python -m pip install --upgrade pip
-
-      - name: Get latest versions and create requirements.txt
-        run: |
-          python -m pip index versions openhands-ai > openhands_versions.txt
-          OPENHANDS_VERSION=$(head -n 1 openhands_versions.txt | awk '{print $2}' | tr -d '()')
-
-          # Create a new requirements.txt locally within the workflow, ensuring no reference to the repo's file
-          echo "openhands-ai==${OPENHANDS_VERSION}" > /tmp/requirements.txt
-          cat /tmp/requirements.txt
-
-      - name: Cache pip dependencies
-        if: |
-          !(
-            github.event.label.name == 'fix-me-experimental' ||
-            (
-              (github.event_name == 'issue_comment' || github.event_name == 'pull_request_review_comment') &&
-              contains(github.event.comment.body, '@openhands-agent-exp')
-            ) ||
-            (
-              github.event_name == 'pull_request_review' &&
-              contains(github.event.review.body, '@openhands-agent-exp')
-            )
-          )
-        uses: actions/cache@v5
-        with:
-          path: ${{ env.pythonLocation }}/lib/python3.12/site-packages/*
-          key: ${{ runner.os }}-pip-openhands-resolver-${{ hashFiles('/tmp/requirements.txt') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-openhands-resolver-${{ hashFiles('/tmp/requirements.txt') }}
-
-      - name: Check required environment variables
-        env:
-          LLM_MODEL: ${{ secrets.LLM_MODEL || inputs.LLM_MODEL }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
-          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-          LLM_API_VERSION: ${{ inputs.LLM_API_VERSION }}
-          PAT_TOKEN: ${{ secrets.PAT_TOKEN }}
-          PAT_USERNAME: ${{ secrets.PAT_USERNAME }}
-          GITHUB_TOKEN: ${{ github.token }}
-        run: |
-          required_vars=("LLM_API_KEY")
-          for var in "${required_vars[@]}"; do
-            if [ -z "${!var}" ]; then
-              echo "Error: Required environment variable $var is not set."
-              exit 1
-            fi
-          done
-
-          # Check optional variables and warn about fallbacks
-          if [ -z "$LLM_BASE_URL" ]; then
-            echo "Warning: LLM_BASE_URL is not set, will use default API endpoint"
-          fi
-
-          if [ -z "$PAT_TOKEN" ]; then
-            echo "Warning: PAT_TOKEN is not set, falling back to GITHUB_TOKEN"
-          fi
-
-          if [ -z "$PAT_USERNAME" ]; then
-            echo "Warning: PAT_USERNAME is not set, will use openhands-agent"
-          fi
-
-      - name: Set environment variables
-        env:
-          REVIEW_BODY: ${{ github.event.review.body || '' }}
-        run: |
-          # Handle pull request events first
-          if [ -n "${{ github.event.pull_request.number }}" ]; then
-            echo "ISSUE_NUMBER=${{ github.event.pull_request.number }}" >> $GITHUB_ENV
-            echo "ISSUE_TYPE=pr" >> $GITHUB_ENV
-          # Handle pull request review events
-          elif [ -n "$REVIEW_BODY" ]; then
-            echo "ISSUE_NUMBER=${{ github.event.pull_request.number }}" >> $GITHUB_ENV
-            echo "ISSUE_TYPE=pr" >> $GITHUB_ENV
-          # Handle issue comment events that reference a PR
-          elif [ -n "${{ github.event.issue.pull_request }}" ]; then
-            echo "ISSUE_NUMBER=${{ github.event.issue.number }}" >> $GITHUB_ENV
-            echo "ISSUE_TYPE=pr" >> $GITHUB_ENV
-          # Handle regular issue events
-          else
-            echo "ISSUE_NUMBER=${{ github.event.issue.number }}" >> $GITHUB_ENV
-            echo "ISSUE_TYPE=issue" >> $GITHUB_ENV
-          fi
-
-          if [ -n "$REVIEW_BODY" ]; then
-            echo "COMMENT_ID=${{ github.event.review.id || 'None' }}" >> $GITHUB_ENV
-          else
-            echo "COMMENT_ID=${{ github.event.comment.id || 'None' }}" >> $GITHUB_ENV
-          fi
-
-          echo "MAX_ITERATIONS=${{ inputs.max_iterations || 50 }}" >> $GITHUB_ENV
-          echo "SANDBOX_ENV_GITHUB_TOKEN=${{ secrets.PAT_TOKEN || github.token }}" >> $GITHUB_ENV
-          echo "SANDBOX_BASE_CONTAINER_IMAGE=${{ inputs.base_container_image }}" >> $GITHUB_ENV
-
-          # Set branch variables
-          echo "TARGET_BRANCH=${{ inputs.target_branch || 'main' }}" >> $GITHUB_ENV
-
-      - name: Comment on issue with start message
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.PAT_TOKEN || github.token }}
-          script: |
-            const issueType = process.env.ISSUE_TYPE;
-            github.rest.issues.createComment({
-              issue_number: ${{ env.ISSUE_NUMBER }},
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: `[OpenHands](https://github.com/OpenHands/OpenHands) started fixing the ${issueType}! You can monitor the progress [here](https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}).`
-            });
-
-      - name: Install OpenHands
-        id: install_openhands
-        uses: actions/github-script@v7
-        env:
-          COMMENT_BODY: ${{ github.event.comment.body || '' }}
-          REVIEW_BODY: ${{ github.event.review.body || '' }}
-          LABEL_NAME: ${{ github.event.label.name || '' }}
-          EVENT_NAME: ${{ github.event_name }}
-        with:
-          script: |
-            const commentBody = process.env.COMMENT_BODY.trim();
-            const reviewBody = process.env.REVIEW_BODY.trim();
-            const labelName = process.env.LABEL_NAME.trim();
-            const eventName = process.env.EVENT_NAME.trim();
-            // Check conditions
-            const isExperimentalLabel = labelName === "fix-me-experimental";
-            const isIssueCommentExperimental =
-              (eventName === "issue_comment" || eventName === "pull_request_review_comment") &&
-              commentBody.includes("@openhands-agent-exp");
-            const isReviewCommentExperimental =
-              eventName === "pull_request_review" && reviewBody.includes("@openhands-agent-exp");
-
-            // Set output variable
-            core.setOutput('isExperimental', isExperimentalLabel || isIssueCommentExperimental || isReviewCommentExperimental);
-
-            // Perform package installation
-            if (isExperimentalLabel || isIssueCommentExperimental || isReviewCommentExperimental) {
-              console.log("Installing experimental OpenHands...");
-
-              await exec.exec("pip install git+https://github.com/openhands/openhands.git");
-            } else {
-              console.log("Installing from requirements.txt...");
-
-              await exec.exec("pip install -r /tmp/requirements.txt");
-            }
-
-      - name: Attempt to resolve issue
-        env:
-          GITHUB_TOKEN: ${{ secrets.PAT_TOKEN || github.token }}
-          GITHUB_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
-          GIT_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
-          LLM_MODEL: ${{ secrets.LLM_MODEL || inputs.LLM_MODEL }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
-          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-          LLM_API_VERSION: ${{ inputs.LLM_API_VERSION }}
-          PYTHONPATH: ""
-        run: |
-          cd /tmp && python -m openhands.resolver.resolve_issue \
-            --selected-repo ${{ github.repository }} \
-            --issue-number ${{ env.ISSUE_NUMBER }} \
-            --issue-type ${{ env.ISSUE_TYPE }} \
-            --max-iterations ${{ env.MAX_ITERATIONS }} \
-            --comment-id ${{ env.COMMENT_ID }} \
-            --is-experimental ${{ steps.install_openhands.outputs.isExperimental }}
-
-      - name: Check resolution result
-        id: check_result
-        run: |
-          if cd /tmp && grep -q '"success":true' output/output.jsonl; then
-            echo "RESOLUTION_SUCCESS=true" >> $GITHUB_OUTPUT
-          else
-            echo "RESOLUTION_SUCCESS=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Upload output.jsonl as artifact
-        uses: actions/upload-artifact@v6
-        if: always() # Upload even if the previous steps fail
-        with:
-          name: resolver-output
-          path: /tmp/output/output.jsonl
-          retention-days: 30 # Keep the artifact for 30 days
-
-      - name: Create draft PR or push branch
-        if: always() # Create PR or branch even if the previous steps fail
-        env:
-          GITHUB_TOKEN: ${{ secrets.PAT_TOKEN || github.token }}
-          GITHUB_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
-          GIT_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
-          LLM_MODEL: ${{ secrets.LLM_MODEL || inputs.LLM_MODEL }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
-          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-          LLM_API_VERSION: ${{ inputs.LLM_API_VERSION }}
-          PYTHONPATH: ""
-        run: |
-          if [ "${{ steps.check_result.outputs.RESOLUTION_SUCCESS }}" == "true" ]; then
-            cd /tmp && python -m openhands.resolver.send_pull_request \
-              --issue-number ${{ env.ISSUE_NUMBER }} \
-              --target-branch ${{ env.TARGET_BRANCH }} \
-              --pr-type ${{ inputs.pr_type || 'draft' }} \
-              --reviewer ${{ github.actor }} | tee pr_result.txt && \
-              grep "PR created" pr_result.txt | sed 's/.*\///g' > pr_number.txt
-          else
-            cd /tmp && python -m openhands.resolver.send_pull_request \
-              --issue-number ${{ env.ISSUE_NUMBER }} \
-              --pr-type branch \
-              --send-on-failure | tee branch_result.txt && \
-              grep "branch created" branch_result.txt | sed 's/.*\///g; s/.expand=1//g' > branch_name.txt
-          fi
-
-      # Step leaves comment for when agent is invoked on PR
-      - name: Analyze Push Logs (Updated PR or No Changes) # Skip comment if PR update was successful OR leave comment if the agent made no code changes
-        uses: actions/github-script@v7
-        if: always()
-        env:
-          AGENT_RESPONDED: ${{ env.AGENT_RESPONDED || 'false' }}
-          ISSUE_NUMBER: ${{ env.ISSUE_NUMBER }}
-        with:
-          github-token: ${{ secrets.PAT_TOKEN || github.token }}
-          script: |
-            const fs = require('fs');
-            const issueNumber = process.env.ISSUE_NUMBER;
-            let logContent = '';
-
-            try {
-              logContent = fs.readFileSync('/tmp/pr_result.txt', 'utf8').trim();
-            } catch (error) {
-              console.error('Error reading pr_result.txt file:', error);
-            }
-
-            const noChangesMessage = `No changes to commit for issue #${issueNumber}. Skipping commit.`;
-
-            // Check logs from send_pull_request.py (pushes code to GitHub)
-            if (logContent.includes("Updated pull request")) {
-              console.log("Updated pull request found. Skipping comment.");
-              process.env.AGENT_RESPONDED = 'true';
-            } else if (logContent.includes(noChangesMessage)) {
-              github.rest.issues.createComment({
-                issue_number: issueNumber,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                body: `The workflow to fix this issue encountered an error. Openhands failed to create any code changes.`
-              });
-              process.env.AGENT_RESPONDED = 'true';
-            }
-
-      # Step leaves comment for when agent is invoked on issue
-      - name: Comment on issue # Comment link to either PR or branch created by agent
-        uses: actions/github-script@v7
-        if: always() # Comment on issue even if the previous steps fail
-        env:
-          AGENT_RESPONDED: ${{ env.AGENT_RESPONDED || 'false' }}
-          ISSUE_NUMBER: ${{ env.ISSUE_NUMBER }}
-          RESOLUTION_SUCCESS: ${{ steps.check_result.outputs.RESOLUTION_SUCCESS }}
-        with:
-          github-token: ${{ secrets.PAT_TOKEN || github.token }}
-          script: |
-            const fs = require('fs');
-            const path = require('path');
-            const issueNumber = process.env.ISSUE_NUMBER;
-            const success = process.env.RESOLUTION_SUCCESS === 'true';
-
-            let prNumber = '';
-            let branchName = '';
-            let resultExplanation = '';
-
-            try {
-              if (success) {
-                prNumber = fs.readFileSync('/tmp/pr_number.txt', 'utf8').trim();
-              } else {
-                branchName = fs.readFileSync('/tmp/branch_name.txt', 'utf8').trim();
-              }
-            } catch (error) {
-              console.error('Error reading file:', error);
-            }
-
-
-            try {
-              if (!success){
-                // Read result_explanation from JSON file for failed resolution
-                const outputFilePath = path.resolve('/tmp/output/output.jsonl');
-                if (fs.existsSync(outputFilePath)) {
-                  const outputContent = fs.readFileSync(outputFilePath, 'utf8');
-                  const jsonLines = outputContent.split('\n').filter(line => line.trim() !== '');
-
-                  if (jsonLines.length > 0) {
-                    // First entry in JSON lines has the key 'result_explanation'
-                    const firstEntry = JSON.parse(jsonLines[0]);
-                    resultExplanation = firstEntry.result_explanation || '';
-                  }
-                }
-              }
-            } catch (error){
-              console.error('Error reading file:', error);
-            }
-
-            // Check "success" log from resolver output
-            if (success && prNumber) {
-              github.rest.issues.createComment({
-                issue_number: issueNumber,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                body: `A potential fix has been generated and a draft PR #${prNumber} has been created. Please review the changes.`
-              });
-              process.env.AGENT_RESPONDED = 'true';
-            } else if (!success && branchName) {
-              let commentBody = `An attempt was made to automatically fix this issue, but it was unsuccessful. A branch named '${branchName}' has been created with the attempted changes. You can view the branch [here](https://github.com/${context.repo.owner}/${context.repo.repo}/tree/${branchName}). Manual intervention may be required.`;
-
-              if (resultExplanation) {
-                commentBody += `\n\nAdditional details about the failure:\n${resultExplanation}`;
-              }
-
-              github.rest.issues.createComment({
-                issue_number: issueNumber,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                body: commentBody
-              });
-              process.env.AGENT_RESPONDED = 'true';
-            }
-
-      # Leave error comment when both PR/Issue comment handling fail
-      - name: Fallback Error Comment
-        uses: actions/github-script@v7
-        if: ${{ env.AGENT_RESPONDED == 'false' }} # Only run if no conditions were met in previous steps
-        env:
-          ISSUE_NUMBER: ${{ env.ISSUE_NUMBER }}
-        with:
-          github-token: ${{ secrets.PAT_TOKEN || github.token }}
-          script: |
-            const issueNumber = process.env.ISSUE_NUMBER;
-
-            github.rest.issues.createComment({
-              issue_number: issueNumber,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: `The workflow to fix this issue encountered an error. Please check the [workflow logs](https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}) for more information.`
-            });

.github/workflows/py-tests.yml

@@ -1,127 +0,0 @@
-# Workflow that runs python tests
-name: Run Python Tests
-
-# The jobs in this workflow are required, so they must run at all times
-# * Always run on "main"
-# * Always run on PRs
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-
-# If triggered by a PR, it will be in the same group. However, each commit on main will be in its own unique group
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  # Run python tests on Linux
-  test-on-linux:
-    name: Python Tests on Linux
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    env:
-      INSTALL_DOCKER: "0" # Set to '0' to skip Docker installation
-    strategy:
-      matrix:
-        python-version: ["3.12"]
-    permissions:
-      # For coverage comment and python-coverage-comment-action branch
-      pull-requests: write
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Install tmux
-        run: sudo apt-get update && sudo apt-get install -y tmux
-      - name: Setup Node.js
-        uses: useblacksmith/setup-node@v5
-        with:
-          node-version: "22.x"
-      - name: Install poetry via pipx
-        run: pipx install poetry
-      - name: Set up Python
-        uses: useblacksmith/setup-python@v6
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: "poetry"
-      - name: Install Python dependencies using Poetry
-        run: |
-          poetry install --with dev,test,runtime
-          poetry run pip install pytest-xdist
-          poetry run pip install pytest-rerunfailures
-      - name: Build Environment
-        run: make build
-      - name: Run Unit Tests
-        run: PYTHONPATH=".:$PYTHONPATH" poetry run pytest --forked -n auto -s ./tests/unit --cov=openhands --cov-branch
-        env:
-          COVERAGE_FILE: ".coverage.${{ matrix.python_version }}"
-      - name: Run Runtime Tests with CLIRuntime
-        run: PYTHONPATH=".:$PYTHONPATH" TEST_RUNTIME=cli poetry run pytest -n 5 --reruns 2 --reruns-delay 3 -s tests/runtime/test_bash.py --cov=openhands --cov-branch
-        env:
-          COVERAGE_FILE: ".coverage.runtime.${{ matrix.python_version }}"
-      - name: Store coverage file
-        uses: actions/upload-artifact@v6
-        with:
-          name: coverage-openhands
-          path: |
-            .coverage.${{ matrix.python_version }}
-            .coverage.runtime.${{ matrix.python_version }}
-          include-hidden-files: true
-
-  test-enterprise:
-    name: Enterprise Python Unit Tests
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    strategy:
-      matrix:
-        python-version: ["3.12"]
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install poetry via pipx
-        run: pipx install poetry
-      - name: Set up Python
-        uses: useblacksmith/setup-python@v6
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: "poetry"
-      - name: Install Python dependencies using Poetry
-        working-directory: ./enterprise
-        run: poetry install --with dev,test
-      - name: Run Unit Tests
-        # Use base working directory for coverage paths to line up.
-        run: PYTHONPATH=".:$PYTHONPATH" poetry run --project=enterprise pytest --forked -n auto -s -p no:ddtrace -p no:ddtrace.pytest_bdd -p no:ddtrace.pytest_benchmark ./enterprise/tests/unit --cov=enterprise --cov-branch
-        env:
-          COVERAGE_FILE: ".coverage.enterprise.${{ matrix.python_version }}"
-      - name: Store coverage file
-        uses: actions/upload-artifact@v6
-        with:
-          name: coverage-enterprise
-          path: ".coverage.enterprise.${{ matrix.python_version }}"
-          include-hidden-files: true
-
-  coverage-comment:
-    name: Coverage Comment
-    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-latest
-    needs: [test-on-linux, test-enterprise]
-
-    permissions:
-      pull-requests: write
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/download-artifact@v6
-        id: download
-        with:
-          pattern: coverage-*
-          merge-multiple: true
-
-      - name: Coverage comment
-        id: coverage_comment
-        uses: py-cov-action/python-coverage-comment-action@v3
-        with:
-          GITHUB_TOKEN: ${{ github.token }}
-          MERGE_COVERAGE_FILES: true

.github/workflows/pypi-release.yml

@@ -1,40 +0,0 @@
-# Publishes the OpenHands PyPi package
-name: Publish PyPi Package
-
-on:
-  workflow_dispatch:
-    inputs:
-      reason:
-        description: "What are you publishing?"
-        required: true
-        type: choice
-        options:
-          - app server
-        default: app server
-  push:
-    tags:
-      - "*"
-
-jobs:
-  release:
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    # Run when manually dispatched for "app server" OR for tag pushes that don't contain '-cli'
-    if: |
-      (github.event_name == 'workflow_dispatch' && github.event.inputs.reason == 'app server')
-      || (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/') && !contains(github.ref, '-cli'))
-    steps:
-      - uses: actions/checkout@v4
-      - uses: useblacksmith/setup-python@v6
-        with:
-          python-version: 3.12
-      - name: Install Poetry
-        uses: snok/install-poetry@v1.4.1
-        with:
-          virtualenvs-in-project: true
-          virtualenvs-path: ~/.virtualenvs
-      - name: Install Poetry Dependencies
-        run: poetry install --no-interaction --no-root
-      - name: Build poetry project
-        run: ./build.sh
-      - name: publish
-        run: poetry publish -u __token__ -p ${{ secrets.PYPI_TOKEN }}

.github/workflows/stale.yml

@@ -1,23 +0,0 @@
-# Workflow that marks issues and PRs with no activity for 30 days with "Stale" and closes them after 7 more days of no activity
-name: 'Close stale issues'
-
-# Runs every day at 01:30
-on:
-  schedule:
-    - cron: '30 1 * * *'
-
-jobs:
-  stale:
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    if: github.repository == 'OpenHands/OpenHands'
-    steps:
-      - uses: actions/stale@v9
-        with:
-          stale-issue-message: 'This issue is stale because it has been open for 40 days with no activity. Remove the stale label or leave a comment, otherwise it will be closed in 10 days.'
-          stale-pr-message: 'This PR is stale because it has been open for 40 days with no activity. Remove the stale label or leave a comment, otherwise it will be closed in 10 days.'
-          days-before-stale: 40
-          exempt-issue-labels: roadmap,backlog,app-team
-          close-issue-message: 'This issue was automatically closed due to 50 days of inactivity. We do this to help keep the issues somewhat manageable and focus on active issues.'
-          close-pr-message: 'This PR was closed because it had no activity for 50 days. If you feel this was closed in error, and you would like to continue the PR, please resubmit or let us know.'
-          days-before-close: 10
-          operations-per-run: 300

.github/workflows/ui-build.yml

@@ -1,34 +0,0 @@
-name: Run UI Component Build
-
-# * Always run on "main"
-# * Run on PRs that have changes in the "openhands-ui" folder or this workflow
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    paths:
-      - 'openhands-ui/**'
-      -  '.github/workflows/ui-build.yml'
-
-# If triggered by a PR, it will be in the same group. However, each commit on main will be in its own unique group
-concurrency:
-  group: ${{ github.workflow }}-${{ (github.head_ref && github.ref) || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  ui-build:
-    name: Build openhands-ui
-    runs-on: blacksmith-4vcpu-ubuntu-2204
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-        with:
-          bun-version-file: "openhands-ui/.bun-version"
-      - name: Install dependencies
-        working-directory: ./openhands-ui
-        run: bun install --frozen-lockfile
-      - name: Build package
-        working-directory:  ./openhands-ui
-        run: bun run build

.github/workflows/welcome-good-first-issue.yml

@@ -1,51 +0,0 @@
-name: Welcome Good First Issue
-
-on:
-  issues:
-    types: [labeled]
-
-permissions:
-  issues: write
-
-jobs:
-  comment-on-good-first-issue:
-    if: github.event.label.name == 'good first issue'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check if welcome comment already exists
-        id: check_comment
-        uses: actions/github-script@v7
-        with:
-          result-encoding: string
-          script: |
-            const issueNumber = context.issue.number;
-            const comments = await github.rest.issues.listComments({
-              ...context.repo,
-              issue_number: issueNumber
-            });
-
-            const alreadyCommented = comments.data.some(
-              (comment) =>
-                comment.body.includes('<!-- auto-comment:good-first-issue -->')
-            );
-
-            return alreadyCommented ? 'true' : 'false';
-
-      - name: Leave welcome comment
-        if: steps.check_comment.outputs.result == 'false'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const repoUrl = `https://github.com/${context.repo.owner}/${context.repo.repo}`;
-
-            await github.rest.issues.createComment({
-              ...context.repo,
-              issue_number: context.issue.number,
-              body: "🙌 **Hey there, future contributor!** 🙌\n\n" +
-                    "This issue has been labeled as **good first issue**, which means it's a great place to get started with the OpenHands project.\n\n" +
-                    "If you're interested in working on it, feel free to! No need to ask for permission.\n\n" +
-                    "Be sure to check out our [development setup guide](" + repoUrl + "/blob/main/Development.md) to get your environment set up, and follow our [contribution guidelines](" + repoUrl + "/blob/main/CONTRIBUTING.md) when you're ready to submit a fix.\n\n" +
-                    "Feel free to join our developer community on [Slack](https://openhands.dev/joinslack). You can ask for [help](https://openhands-ai.slack.com/archives/C078L0FUGUX), [feedback](https://openhands-ai.slack.com/archives/C086ARSNMGA), and even ask for a [PR review](https://openhands-ai.slack.com/archives/C08D8FJ5771).\n\n" +
-                    "🙌 Happy hacking! 🙌\n\n" +
-                    "<!-- auto-comment:good-first-issue -->"
-            });

.gitignore

@@ -1,264 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-./lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-requirements.txt
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-.python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-# poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-frontend/.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-.env.bak
-venv.bak/
-*venv/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
-
-# VS Code: Ignore all but certain files that specify repo-specific settings.
-# https://stackoverflow.com/questions/32964920/should-i-commit-the-vscode-folder-to-source-control
-.vscode/**/*
-!.vscode/extensions.json
-!.vscode/settings.json
-!.vscode/tasks.json
-
-# VS Code extensions/forks:
-.cursorignore
-.rooignore
-.clineignore
-.windsurfignore
-.cursorrules
-.roorules
-.clinerules
-.windsurfrules
-.cursor/rules
-.roo/rules
-.cline/rules
-.windsurf/rules
-.repomix
-repomix-output.txt
-
-# Emacs backup
-*~
-
-# evaluation
-evaluation/evaluation_outputs
-evaluation/outputs
-evaluation/swe_bench/eval_workspace*
-evaluation/SWE-bench/data
-evaluation/webarena/scripts/webarena_env.sh
-evaluation/bird/data
-evaluation/gaia/data
-evaluation/gorilla/data
-evaluation/toolqa/data
-evaluation/scienceagentbench/benchmark
-evaluation/commit0_bench/repos
-
-# openhands resolver
-output/
-
-# frontend
-
-# dependencies
-frontend/.pnp
-frontend/bun.lockb
-frontend/yarn.lock
-.pnp.js
-
-# testing
-frontend/coverage
-test_results*
-/_test_files_tmp/
-
-# production
-frontend/build
-frontend/dist
-
-# misc
-.DS_Store
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-logs
-
-# agent
-.envrc
-/workspace
-/_test_workspace
-/debug
-cache
-
-# configuration
-config.toml
-config.toml_
-config.toml.bak
-
-# swe-bench-eval
-image_build_logs
-run_instance_logs
-
-runtime_*.tar
-
-# docker build
-containers/runtime/Dockerfile
-containers/runtime/project.tar.gz
-containers/runtime/code
-**/node_modules/
-
-# test results
-test-results
-.sessions
-.eval_sessions

.nvmrc

@@ -1 +0,0 @@
-22

.openhands/microagents/documentation.md

@@ -1,33 +0,0 @@
----
-name: documentation
-type: knowledge
-version: 1.0.0
-agent: CodeActAgent
-triggers:
-- documentation
-- docs
-- document
----
-
-# Documentation Guidelines
-
-All documentation must be grounded in fact, so you must not make anything up without proper evidence. When you have finished writing documentation, convey to the user what reference source, including web pages, source code, or other sources of documentation you referenced when writing each new fact in the documentation. If you cannot reference a source for anything do not include it in the pull request.
-
-## Best Practices for Documentation
-
-1. **Be Factual**: Only include information that can be verified from reliable sources.
-2. **Cite Sources**: Always reference the source of information (code, web pages, official documentation).
-3. **Be Clear and Concise**: Use simple language and avoid unnecessary jargon.
-4. **Use Examples**: Include practical examples to illustrate concepts.
-5. **Structure Properly**: Use headings, lists, and code blocks to organize information.
-6. **Keep Updated**: Ensure documentation reflects the current state of the code or system.
-
-## Documentation Process
-
-1. Research and gather information from reliable sources
-2. Draft documentation based on verified facts
-3. Review for accuracy and completeness
-4. Include references for all factual statements
-5. Submit only when all information is properly sourced
-
-Remember: If you cannot verify a piece of information, it's better to exclude it than to include potentially incorrect information.

.openhands/microagents/glossary.md

@@ -1,172 +0,0 @@
-# OpenHands Glossary
-
-### Agent
-The core AI entity in OpenHands that can perform software development tasks by interacting with tools, browsing the web, and modifying code.
-
-#### Agent Controller
-A component that manages the agent's lifecycle, handles its state, and coordinates interactions between the agent and various tools.
-
-#### Agent Delegation
-The ability of an agent to hand off specific tasks to other specialized agents for better task completion.
-
-#### Agent Hub
-A central registry of different agent types and their capabilities, allowing for easy agent selection and instantiation.
-
-#### Agent Skill
-A specific capability or function that an agent can perform, such as file manipulation, web browsing, or code editing.
-
-#### Agent State
-The current context and status of an agent, including its memory, active tools, and ongoing tasks.
-
-#### CodeAct Agent
-[A generalist agent in OpenHands](https://arxiv.org/abs/2407.16741) designed to perform tasks by editing and executing code.
-
-### Browser
-A system for web-based interactions and tasks.
-
-#### Browser Gym
-A testing and evaluation environment for browser-based agent interactions and tasks.
-
-#### Web Browser Tool
-A tool that enables agents to interact with web pages and perform web-based tasks.
-
-### Commands
-Terminal and execution related functionality.
-
-#### Bash Session
-A persistent terminal session that maintains state and history for bash command execution.
-This uses tmux under the hood.
-
-### Configuration
-System-wide settings and options.
-
-#### Agent Configuration
-Settings that define an agent's behavior, capabilities, and limitations, including available tools and runtime settings.
-
-#### Configuration Options
-Settings that control various aspects of OpenHands behavior, including runtime, security, and agent settings.
-
-#### LLM Config
-Configuration settings for language models used by agents, including model selection and parameters.
-
-#### LLM Draft Config
-Settings for draft mode operations with language models, typically used for faster, lower-quality responses.
-
-#### Runtime Configuration
-Settings that define how the runtime environment should be set up and operated.
-
-#### Security Options
-Configuration settings that control security features and restrictions.
-
-### Conversation
-A sequence of interactions between a user and an agent, including messages, actions, and their results.
-
-#### Conversation Info
-Metadata about a conversation, including its status, participants, and timeline.
-
-#### Conversation Manager
-A component that handles the creation, storage, and retrieval of conversations.
-
-#### Conversation Metadata
-Additional information about conversations, such as tags, timestamps, and related resources.
-
-#### Conversation Status
-The current state of a conversation, including whether it's active, completed, or failed.
-
-#### Conversation Store
-A storage system for maintaining conversation history and related data.
-
-### Events
-
-#### Event
-Every Conversation comprises a series of Events. Each Event is either an Action or an Observation.
-
-#### Event Stream
-A continuous flow of events that represents the ongoing activities and interactions in the system.
-
-#### Action
-A specific operation or command that an agent executes through available tools, such as running a command or editing a file.
-
-#### Observation
-The response or result returned by a tool after an agent's action, providing feedback about the action's outcome.
-
-### Interface
-Different ways to interact with OpenHands.
-
-#### CLI Mode
-A command-line interface mode for interacting with OpenHands agents without a graphical interface.
-
-#### GUI Mode
-A graphical user interface mode for interacting with OpenHands agents through a web interface.
-
-#### Headless Mode
-A mode of operation where OpenHands runs without a user interface, suitable for automation and scripting.
-
-### Agent Memory
-The system that decides which parts of the Event Stream (i.e. the conversation history) should be passed into each LLM prompt.
-
-#### Memory Store
-A storage system for maintaining agent memory and context across sessions.
-
-#### Condenser
-A component that processes and summarizes conversation history to maintain context while staying within token limits.
-
-#### Truncation
-A very simple Condenser strategy. Reduces conversation history or content to stay within token limits.
-
-### Microagent
-A specialized prompt that enhances OpenHands with domain-specific knowledge, repository-specific context, and task-specific workflows.
-
-#### Microagent Registry
-A central repository of available microagents and their configurations.
-
-#### Public Microagent
-A general-purpose microagent available to all OpenHands users, triggered by specific keywords. Located in `microagents/`.
-
-#### Repository Microagent
-A type of microagent that provides repository-specific context and guidelines, stored in the `.openhands/microagents/` directory.
-
-### Prompt
-Components for managing and processing prompts.
-
-#### Prompt Caching
-A system for caching and reusing common prompts to improve performance.
-
-#### Prompt Manager
-A component that handles the loading, processing, and management of prompts used by agents, including microagents.
-
-#### Response Parsing
-The process of interpreting and structuring responses from language models and tools.
-
-### Runtime
-The execution environment where agents perform their tasks, which can be local, remote, or containerized.
-
-#### Action Execution Server
-A REST API that receives agent actions (e.g. bash commands, python code, browsing actions), executes them in the runtime environment, and returns the results.
-
-#### Action Execution Client
-A component that handles the execution of actions in the runtime environment, managing the communication between the agent and the runtime.
-
-#### Docker Runtime
-A containerized runtime environment that provides isolation and reproducibility for agent operations.
-
-#### E2B Runtime
-A specialized runtime environment built on E2B for secure and isolated code execution.
-
-#### Local Runtime
-A runtime environment that executes on the local machine, suitable for development and testing.
-
-#### Modal Runtime
-A runtime environment built on Modal for scalable and distributed agent operations.
-
-#### Remote Runtime
-A sandboxed environment that executes code and commands remotely, providing isolation and security for agent operations.
-
-#### Runtime Builder
-A component that builds a Docker image for the Action Execution Server based on a user-specified base image.
-
-### Security
-Security-related components and features.
-
-#### Security Analyzer
-A component that checks agent actions for potential security risks.

.openhands/pre-commit.sh

@@ -1,124 +0,0 @@
-#!/bin/bash
-
-echo "Running OpenHands pre-commit hook..."
-echo "This hook runs selective linting based on changed files."
-
-# Store the exit code to return at the end
-# This allows us to be additive to existing pre-commit hooks
-EXIT_CODE=0
-
-# Get the list of staged files
-STAGED_FILES=$(git diff --cached --name-only)
-
-# Check if any files match specific patterns
-has_frontend_changes=false
-has_backend_changes=false
-
-# Check each file individually to avoid issues with grep
-for file in $STAGED_FILES; do
-    if [[ $file == frontend/* ]]; then
-        has_frontend_changes=true
-    elif [[ $file == openhands/* || $file == evaluation/* || $file == tests/* ]]; then
-        has_backend_changes=true
-    fi
-done
-
-echo "Analyzing changes..."
-echo "- Frontend changes: $has_frontend_changes"
-echo "- Backend changes: $has_backend_changes"
-
-# Run frontend linting if needed
-if [ "$has_frontend_changes" = true ]; then
-    # Check if we're in a CI environment or if frontend dependencies are missing
-    if [ -n "$CI" ] || ! command -v react-router &> /dev/null || ! command -v vitest &> /dev/null; then
-        echo "Skipping frontend checks (CI environment or missing dependencies detected)."
-        echo "WARNING: Frontend files have changed but frontend checks are being skipped."
-        echo "Please run 'make lint-frontend' manually before submitting your PR."
-    else
-        echo "Running frontend linting..."
-        make lint-frontend
-        if [ $? -ne 0 ]; then
-            echo "Frontend linting failed. Please fix the issues before committing."
-            EXIT_CODE=1
-        else
-            echo "Frontend linting checks passed!"
-        fi
-
-        # Run additional frontend checks
-        if [ -d "frontend" ]; then
-            echo "Running additional frontend checks..."
-            cd frontend || exit 1
-
-            # Run build
-            echo "Running npm build..."
-            npm run build
-            if [ $? -ne 0 ]; then
-                echo "Frontend build failed. Please fix the issues before committing."
-                EXIT_CODE=1
-            fi
-
-            # Run tests
-            echo "Running npm test..."
-            npm test
-            if [ $? -ne 0 ]; then
-                echo "Frontend tests failed. Please fix the failing tests before committing."
-                EXIT_CODE=1
-            fi
-
-            cd ..
-        fi
-    fi
-else
-    echo "Skipping frontend checks (no frontend changes detected)."
-fi
-
-# Run backend linting if needed
-if [ "$has_backend_changes" = true ]; then
-    echo "Running backend linting..."
-    make lint-backend
-    if [ $? -ne 0 ]; then
-        echo "Backend linting failed. Please fix the issues before committing."
-        EXIT_CODE=1
-    else
-        echo "Backend linting checks passed!"
-    fi
-else
-    echo "Skipping backend checks (no backend changes detected)."
-fi
-
-
-# If no specific code changes detected, run basic checks
-if [ "$has_frontend_changes" = false ] && [ "$has_backend_changes" = false ]; then
-    echo "No specific code changes detected. Running basic checks..."
-    if [ -n "$STAGED_FILES" ]; then
-        # Run only basic pre-commit hooks for non-code files
-        poetry run pre-commit run --files $(echo "$STAGED_FILES" | tr '\n' ' ') --hook-stage commit --config ./dev_config/python/.pre-commit-config.yaml
-        if [ $? -ne 0 ]; then
-            echo "Basic checks failed. Please fix the issues before committing."
-            EXIT_CODE=1
-        else
-            echo "Basic checks passed!"
-        fi
-    else
-        echo "No files changed. Skipping basic checks."
-    fi
-fi
-
-# Run any existing pre-commit hooks that might have been installed by the user
-# This makes our hook additive rather than replacing existing hooks
-if [ -f ".git/hooks/pre-commit.local" ]; then
-    echo "Running existing pre-commit hooks..."
-    bash .git/hooks/pre-commit.local
-    if [ $? -ne 0 ]; then
-        echo "Existing pre-commit hooks failed."
-        EXIT_CODE=1
-    fi
-fi
-
-if [ $EXIT_CODE -eq 0 ]; then
-    echo "All pre-commit checks passed!"
-else
-    echo "Some pre-commit checks failed. Please fix the issues before committing."
-fi
-
-exit $EXIT_CODE

.openhands/setup.sh

@@ -1,13 +0,0 @@
-#! /bin/bash
-
-echo "Setting up the environment..."
-
-# Install pre-commit package
-python -m pip install pre-commit
-
-# Install pre-commit hooks if .git directory exists
-if [ -d ".git" ]; then
-    echo "Installing pre-commit hooks..."
-    pre-commit install
-    make install-pre-commit-hooks
-fi

.vscode/settings.json

@@ -1,22 +0,0 @@
-{
-    // force *nix line endings so files don't look modified in container run from Windows clone
-    "files.eol": "\n",
-    "files.trimTrailingWhitespace": true,
-    "files.insertFinalNewline": true,
-
-    "python.defaultInterpreterPath": "./.venv/bin/python",
-    "python.terminal.activateEnvironment": true,
-    "python.analysis.autoImportCompletions": true,
-    "python.analysis.autoSearchPaths": true,
-    "python.analysis.extraPaths": [
-        "./.venv/lib/python3.12/site-packages"
-    ],
-    "python.analysis.packageIndexDepths": [
-        {
-            "name": "openhands",
-            "depth": 10,
-            "includeAllSymbols": true
-        }
-    ],
-    "python.analysis.stubPath": "./.venv/lib/python3.12/site-packages",
-}

AGENTS.md

@@ -1,344 +0,0 @@
-This repository contains the code for OpenHands, an automated AI software engineer. It has a Python backend
-(in the `openhands` directory) and React frontend (in the `frontend` directory).
-
-## General Setup:
-To set up the entire repo, including frontend and backend, run `make build`.
-You don't need to do this unless the user asks you to, or if you're trying to run the entire application.
-
-## Running OpenHands with OpenHands:
-To run the full application to debug issues:
-```bash
-export INSTALL_DOCKER=0
-export RUNTIME=local
-make build && make run FRONTEND_PORT=12000 FRONTEND_HOST=0.0.0.0 BACKEND_HOST=0.0.0.0 &> /tmp/openhands-log.txt &
-```
-
-IMPORTANT: Before making any changes to the codebase, ALWAYS run `make install-pre-commit-hooks` to ensure pre-commit hooks are properly installed.
-
-Before pushing any changes, you MUST ensure that any lint errors or simple test errors have been fixed.
-
-* If you've made changes to the backend, you should run `pre-commit run --config ./dev_config/python/.pre-commit-config.yaml` (this will run on staged files).
-* If you've made changes to the frontend, you should run `cd frontend && npm run lint:fix && npm run build ; cd ..`
-* If you've made changes to the VSCode extension, you should run `cd openhands/integrations/vscode && npm run lint:fix && npm run compile ; cd ../../..`
-
-The pre-commit hooks MUST pass successfully before pushing any changes to the repository. This is a mandatory requirement to maintain code quality and consistency.
-
-If either command fails, it may have automatically fixed some issues. You should fix any issues that weren't automatically fixed,
-then re-run the command to ensure it passes. Common issues include:
-- Mypy type errors
-- Ruff formatting issues
-- Trailing whitespace
-- Missing newlines at end of files
-
-## Git Best Practices
-
-- Prefer specific `git add <filename>` instead of `git add .` to avoid accidentally staging unintended files
-- Be especially careful with `git reset --hard` after staging files, as it will remove accidentally staged files
-- When remote has new changes, use `git fetch upstream && git rebase upstream/<branch>` on the same branch
-
-## Repository Structure
-Backend:
-- Located in the `openhands` directory
-- Testing:
-  - All tests are in `tests/unit/test_*.py`
-  - To test new code, run `poetry run pytest tests/unit/test_xxx.py` where `xxx` is the appropriate file for the current functionality
-  - Write all tests with pytest
-
-Frontend:
-- Located in the `frontend` directory
-- Prerequisites: A recent version of NodeJS / NPM
-- Setup: Run `npm install` in the frontend directory
-- Testing:
-  - Run tests: `npm run test`
-  - To run specific tests: `npm run test -- -t "TestName"`
-  - Our test framework is vitest
-- Building:
-  - Build for production: `npm run build`
-- Environment Variables:
-  - Set in `frontend/.env` or as environment variables
-  - Available variables: VITE_BACKEND_HOST, VITE_USE_TLS, VITE_INSECURE_SKIP_VERIFY, VITE_FRONTEND_PORT
-- Internationalization:
-  - Generate i18n declaration file: `npm run make-i18n`
-- Data Fetching & Cache Management:
-  - We use TanStack Query (fka React Query) for data fetching and cache management
-  - Data Access Layer: API client methods are located in `frontend/src/api` and should never be called directly from UI components - they must always be wrapped with TanStack Query
-  - Custom hooks are located in `frontend/src/hooks/query/` and `frontend/src/hooks/mutation/`
-  - Query hooks should follow the pattern use[Resource] (e.g., `useConversationSkills`)
-  - Mutation hooks should follow the pattern use[Action] (e.g., `useDeleteConversation`)
-  - Architecture rule: UI components → TanStack Query hooks → Data Access Layer (`frontend/src/api`) → API endpoints
-
-VSCode Extension:
-- Located in the `openhands/integrations/vscode` directory
-- Setup: Run `npm install` in the extension directory
-- Linting:
-  - Run linting with fixes: `npm run lint:fix`
-  - Check only: `npm run lint`
-  - Type checking: `npm run typecheck`
-- Building:
-  - Compile TypeScript: `npm run compile`
-  - Package extension: `npm run package-vsix`
-- Testing:
-  - Run tests: `npm run test`
-- Development Best Practices:
-  - Use `vscode.window.createOutputChannel()` for debug logging instead of `showErrorMessage()` popups
-  - Pre-commit process runs both frontend and backend checks when committing extension changes
-
-## Enterprise Directory
-
-The `enterprise/` directory contains additional functionality that extends the open-source OpenHands codebase. This includes:
-- Authentication and user management (Keycloak integration)
-- Database migrations (Alembic)
-- Integration services (GitHub, GitLab, Jira, Linear, Slack)
-- Billing and subscription management (Stripe)
-- Telemetry and analytics (PostHog, custom metrics framework)
-
-### Enterprise Development Setup
-
-**Prerequisites:**
-- Python 3.12
-- Poetry (for dependency management)
-- Node.js 22.x (for frontend)
-- Docker (optional)
-
-**Setup Steps:**
-1. First, build the main OpenHands project: `make build`
-2. Then install enterprise dependencies: `cd enterprise && poetry install --with dev,test` (This can take a very long time. Be patient.)
-3. Set up enterprise pre-commit hooks: `poetry run pre-commit install --config ./dev_config/python/.pre-commit-config.yaml`
-
-**Running Enterprise Tests:**
-```bash
-# Enterprise unit tests (full suite)
-PYTHONPATH=".:$PYTHONPATH" poetry run --project=enterprise pytest --forked -n auto -s -p no:ddtrace -p no:ddtrace.pytest_bdd -p no:ddtrace.pytest_benchmark ./enterprise/tests/unit --cov=enterprise --cov-branch
-
-# Test specific modules (faster for development)
-cd enterprise
-PYTHONPATH=".:$PYTHONPATH" poetry run pytest tests/unit/telemetry/ --confcutdir=tests/unit/telemetry
-
-# Enterprise linting (IMPORTANT: use --show-diff-on-failure to match GitHub CI)
-poetry run pre-commit run --all-files --show-diff-on-failure --config ./dev_config/python/.pre-commit-config.yaml
-```
-
-**Running Enterprise Server:**
-```bash
-cd enterprise
-make start-backend  # Development mode with hot reload
-# or
-make run  # Full application (backend + frontend)
-```
-
-**Key Configuration Files:**
-- `enterprise/pyproject.toml` - Enterprise-specific dependencies
-- `enterprise/Makefile` - Enterprise build and run commands
-- `enterprise/dev_config/python/` - Linting and type checking configuration
-- `enterprise/migrations/` - Database migration files
-
-**Database Migrations:**
-Enterprise uses Alembic for database migrations. When making schema changes:
-1. Create migration files in `enterprise/migrations/versions/`
-2. Test migrations thoroughly
-3. The CI will check for migration conflicts on PRs
-
-**Integration Development:**
-The enterprise codebase includes integrations for:
-- **GitHub** - PR management, webhooks, app installations
-- **GitLab** - Similar to GitHub but for GitLab instances
-- **Jira** - Issue tracking and project management
-- **Linear** - Modern issue tracking
-- **Slack** - Team communication and notifications
-
-Each integration follows a consistent pattern with service classes, storage models, and API endpoints.
-
-**Important Notes:**
-- Enterprise code is licensed under Polyform Free Trial License (30-day limit)
-- The enterprise server extends the OpenHands server through dynamic imports
-- Database changes require careful migration planning in `enterprise/migrations/`
-- Always test changes in both OpenHands and enterprise contexts
-- Use the enterprise-specific Makefile commands for development
-
-**Enterprise Testing Best Practices:**
-
-**Database Testing:**
-- Use SQLite in-memory databases (`sqlite:///:memory:`) for unit tests instead of real PostgreSQL
-- Create module-specific `conftest.py` files with database fixtures
-- Mock external database connections in unit tests to avoid dependency on running services
-- Use real database connections only for integration tests
-
-**Import Patterns:**
-- Use relative imports without `enterprise.` prefix in enterprise code
-- Example: `from storage.database import session_maker` not `from enterprise.storage.database import session_maker`
-- This ensures code works in both OpenHands and enterprise contexts
-
-**Test Structure:**
-- Place tests in `enterprise/tests/unit/` following the same structure as the source code
-- Use `--confcutdir=tests/unit/[module]` when testing specific modules
-- Create comprehensive fixtures for complex objects (databases, external services)
-- Write platform-agnostic tests (avoid hardcoded OS-specific assertions)
-
-**Mocking Strategy:**
-- Use `AsyncMock` for async operations and `MagicMock` for complex objects
-- Mock all external dependencies (databases, APIs, file systems) in unit tests
-- Use `patch` with correct import paths (e.g., `telemetry.registry.logger` not `enterprise.telemetry.registry.logger`)
-- Test both success and failure scenarios with proper error handling
-
-**Coverage Goals:**
-- Aim for 90%+ test coverage on new enterprise modules
-- Focus on critical business logic and error handling paths
-- Use `--cov-report=term-missing` to identify uncovered lines
-
-**Troubleshooting:**
-- If tests fail, ensure all dependencies are installed: `poetry install --with dev,test`
-- For database issues, check migration status and run migrations if needed
-- For frontend issues, ensure the main OpenHands frontend is built: `make build`
-- Check logs in the `logs/` directory for runtime issues
-- If tests fail with import errors, verify `PYTHONPATH=".:$PYTHONPATH"` is set
-- **If GitHub CI fails but local linting passes**: Always use `--show-diff-on-failure` flag to match CI behavior exactly
-
-## Template for Github Pull Request
-
-If you are starting a pull request (PR), please follow the template in `.github/pull_request_template.md`.
-
-## Implementation Details
-
-These details may or may not be useful for your current task.
-
-### Microagents
-
-Microagents are specialized prompts that enhance OpenHands with domain-specific knowledge and task-specific workflows. They are Markdown files that can include frontmatter for configuration.
-
-#### Types:
-- **Public Microagents**: Located in `microagents/`, available to all users
-- **Repository Microagents**: Located in `.openhands/microagents/`, specific to this repository
-
-#### Loading Behavior:
-- **Without frontmatter**: Always loaded into LLM context
-- **With triggers in frontmatter**: Only loaded when user's message matches the specified trigger keywords
-
-#### Structure:
-```yaml
----
-triggers:
-- keyword1
-- keyword2
----
-# Microagent Content
-Your specialized knowledge and instructions here...
-```
-
-### Frontend
-
-#### Action Handling:
-- Actions are defined in `frontend/src/types/action-type.ts`
-- The `HANDLED_ACTIONS` array in `frontend/src/state/chat-slice.ts` determines which actions are displayed as collapsible UI elements
-- To add a new action type to the UI:
-  1. Add the action type to the `HANDLED_ACTIONS` array
-  2. Implement the action handling in `addAssistantAction` function in chat-slice.ts
-  3. Add a translation key in the format `ACTION_MESSAGE$ACTION_NAME` to the i18n files
-- Actions with `thought` property are displayed in the UI based on their action type:
-  - Regular actions (like "run", "edit") display the thought as a separate message
-  - Special actions (like "think") are displayed as collapsible elements only
-
-#### Adding User Settings:
-- To add a new user setting to OpenHands, follow these steps:
-  1. Add the setting to the frontend:
-     - Add the setting to the `Settings` type in `frontend/src/types/settings.ts`
-     - Add the setting to the `ApiSettings` type in the same file
-     - Add the setting with an appropriate default value to `DEFAULT_SETTINGS` in `frontend/src/services/settings.ts`
-     - Update the `useSettings` hook in `frontend/src/hooks/query/use-settings.ts` to map the API response
-     - Update the `useSaveSettings` hook in `frontend/src/hooks/mutation/use-save-settings.ts` to include the setting in API requests
-     - Add UI components (like toggle switches) in the appropriate settings screen (e.g., `frontend/src/routes/app-settings.tsx`)
-     - Add i18n translations for the setting name and any tooltips in `frontend/src/i18n/translation.json`
-     - Add the translation key to `frontend/src/i18n/declaration.ts`
-  2. Add the setting to the backend:
-     - Add the setting to the `Settings` model in `openhands/storage/data_models/settings.py`
-     - Update any relevant backend code to apply the setting (e.g., in session creation)
-
-#### Settings UI Patterns:
-
-There are two main patterns for saving settings in the OpenHands frontend:
-
-**Pattern 1: Entity-based Resources (Immediate Save)**
-- Used for: API Keys, Secrets, MCP Servers
-- Behavior: Changes are saved immediately when user performs actions (add/edit/delete)
-- Implementation:
-  - No "Save Changes" button
-  - No local state management or `isDirty` tracking
-  - Uses dedicated mutation hooks for each operation (e.g., `use-add-mcp-server.ts`, `use-delete-mcp-server.ts`)
-  - Each mutation triggers immediate API call with query invalidation for UI updates
-  - Example: MCP settings, API Keys & Secrets tabs
-- Benefits: Simpler UX, no risk of losing changes, consistent with modern web app patterns
-
-**Pattern 2: Form-based Settings (Manual Save)**
-- Used for: Application settings, LLM configuration
-- Behavior: Changes are accumulated locally and saved when user clicks "Save Changes"
-- Implementation:
-  - Has "Save Changes" button that becomes enabled when changes are detected
-  - Uses local state management with `isDirty` tracking
-  - Uses `useSaveSettings` hook to save all changes at once
-  - Example: LLM tab, Application tab
-- Benefits: Allows bulk changes, explicit save action, can validate all fields before saving
-
-**When to use each pattern:**
-- Use Pattern 1 (Immediate Save) for entity management where each item is independent
-- Use Pattern 2 (Manual Save) for configuration forms where settings are interdependent or need validation
-
-### Adding New LLM Models
-
-To add a new LLM model to OpenHands, you need to update multiple files across both frontend and backend:
-
-#### Model Configuration Procedure:
-
-1. **Frontend Model Arrays** (`frontend/src/utils/verified-models.ts`):
-   - Add the model to `VERIFIED_MODELS` array (main list of all verified models)
-   - Add to provider-specific arrays based on the model's provider:
-     - `VERIFIED_OPENAI_MODELS` for OpenAI models
-     - `VERIFIED_ANTHROPIC_MODELS` for Anthropic models
-     - `VERIFIED_MISTRAL_MODELS` for Mistral models
-     - `VERIFIED_OPENHANDS_MODELS` for models available through OpenHands provider
-
-2. **Backend CLI Integration** (`openhands/cli/utils.py`):
-   - Add the model to the appropriate `VERIFIED_*_MODELS` arrays
-   - This ensures the model appears in CLI model selection
-
-3. **Backend Model List** (`openhands/utils/llm.py`):
-   - **CRITICAL**: Add the model to the `openhands_models` list (lines 57-66) if using OpenHands provider
-   - This is required for the model to appear in the frontend model selector
-   - Format: `'openhands/model-name'` (e.g., `'openhands/o3'`)
-
-4. **Backend LLM Configuration** (`openhands/llm/llm.py`):
-   - Add to feature-specific arrays based on model capabilities:
-     - `FUNCTION_CALLING_SUPPORTED_MODELS` if the model supports function calling
-     - `REASONING_EFFORT_SUPPORTED_MODELS` if the model supports reasoning effort parameters
-     - `CACHE_PROMPT_SUPPORTED_MODELS` if the model supports prompt caching
-     - `MODELS_WITHOUT_STOP_WORDS` if the model doesn't support stop words
-
-5. **Validation**:
-   - Run backend linting: `pre-commit run --config ./dev_config/python/.pre-commit-config.yaml`
-   - Run frontend linting: `cd frontend && npm run lint:fix`
-   - Run frontend build: `cd frontend && npm run build`
-
-#### Model Verification Arrays:
-
-- **VERIFIED_MODELS**: Main array of all verified models shown in the UI
-- **VERIFIED_OPENAI_MODELS**: OpenAI models (LiteLLM doesn't return provider prefix)
-- **VERIFIED_ANTHROPIC_MODELS**: Anthropic models (LiteLLM doesn't return provider prefix)
-- **VERIFIED_MISTRAL_MODELS**: Mistral models (LiteLLM doesn't return provider prefix)
-- **VERIFIED_OPENHANDS_MODELS**: Models available through OpenHands managed provider
-
-#### Model Feature Support Arrays:
-
-- **FUNCTION_CALLING_SUPPORTED_MODELS**: Models that support structured function calling
-- **REASONING_EFFORT_SUPPORTED_MODELS**: Models that support reasoning effort parameters (like o1, o3)
-- **CACHE_PROMPT_SUPPORTED_MODELS**: Models that support prompt caching for efficiency
-- **MODELS_WITHOUT_STOP_WORDS**: Models that don't support stop word parameters
-
-#### Frontend Model Integration:
-
-- Models are automatically available in the model selector UI once added to verified arrays
-- The `extractModelAndProvider` utility automatically detects provider from model arrays
-- Provider-specific models are grouped and prioritized in the UI selection
-
-#### CLI Model Integration:
-
-- Models appear in CLI provider selection based on the verified arrays
-- The `organize_models_and_providers` function groups models by provider
-- Default model selection prioritizes verified models for each provider

CITATION.cff

@@ -1,55 +0,0 @@
-cff-version: 1.2.0
-message: "If you use this software, please cite it using the following metadata."
-title: "OpenHands: An Open Platform for AI Software Developers as Generalist Agents"
-authors:
-  - family-names: Wang
-    given-names: Xingyao
-  - family-names: Li
-    given-names: Boxuan
-  - family-names: Song
-    given-names: Yufan
-  - family-names: Xu
-    given-names: Frank F.
-  - family-names: Tang
-    given-names: Xiangru
-  - family-names: Zhuge
-    given-names: Mingchen
-  - family-names: Pan
-    given-names: Jiayi
-  - family-names: Song
-    given-names: Yueqi
-  - family-names: Li
-    given-names: Bowen
-  - family-names: Singh
-    given-names: Jaskirat
-  - family-names: Tran
-    given-names: Hoang H.
-  - family-names: Li
-    given-names: Fuqiang
-  - family-names: Ma
-    given-names: Ren
-  - family-names: Zheng
-    given-names: Mingzhang
-  - family-names: Qian
-    given-names: Bill
-  - family-names: Shao
-    given-names: Yanjun
-  - family-names: Muennighoff
-    given-names: Niklas
-  - family-names: Zhang
-    given-names: Yizhe
-  - family-names: Hui
-    given-names: Binyuan
-  - family-names: Lin
-    given-names: Junyang
-  - family-names: Brennan
-    given-names: Robert
-  - family-names: Peng
-    given-names: Hao
-  - family-names: Ji
-    given-names: Heng
-  - family-names: Neubig
-    given-names: Graham
-year: 2024
-doi: "10.48550/arXiv.2407.16741"
-url: "https://arxiv.org/abs/2407.16741"

CNAME

@@ -1 +0,0 @@
-docs.all-hands.dev

CODE_OF_CONDUCT.md

@@ -1,152 +0,0 @@
-
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, caste, color, religion, or sexual
-identity and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people.
-* Being respectful of differing opinions, viewpoints, and experiences.
-* Giving and gracefully accepting constructive feedback.
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience.
-* Focusing on what is best not just for us as individuals, but for the overall
-  community.
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or advances of
-  any kind.
-* Trolling, insulting or derogatory comments, and personal or political attacks.
-* Public or private harassment.
-* Publishing others' private information, such as a physical or email address,
-  without their explicit permission.
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting.
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official email address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-contact@openhands.dev.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series of
-actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or permanent
-ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior, harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within the
-community.
-
-### Slack Etiquettes
-
-These Slack etiquette guidelines are designed to foster an inclusive, respectful, and productive environment for all
-community members. By following these best practices, we ensure effective communication and collaboration while
-minimizing disruptions. Let’s work together to build a supportive and welcoming community!
-
-- Communicate respectfully and professionally, avoiding sarcasm or harsh language, and remember that tone can be difficult to interpret in text.
-- Use threads for specific discussions to keep channels organized and easier to follow.
-- Tag others only when their input is critical or urgent, and use @here, @channel or @everyone sparingly to minimize disruptions.
-- Be patient, as open-source contributors and maintainers often have other commitments and may need time to respond.
-- Post questions or discussions in the most relevant channel (e.g., for [slack - #general](https://openhands-ai.slack.com/archives/C06P5NCGSFP) for general topics, [slack - #questions](https://openhands-ai.slack.com/archives/C06U8UTKSAD) for queries/questions.
-- When asking for help or raising issues, include necessary details like links, screenshots, or clear explanations to provide context.
-- Keep discussions in public channels whenever possible to allow others to benefit from the conversation, unless the matter is sensitive or private.
-- Always adhere to [our standards](https://github.com/OpenHands/OpenHands/blob/main/CODE_OF_CONDUCT.md#our-standards) to ensure a welcoming and collaborative environment.
-- If you choose to mute a channel, consider setting up alerts for topics that still interest you to stay engaged.
-   For Slack, Go to Settings → Notifications → My Keywords to add specific keywords that will notify you when mentioned.
-   For example, if you're here for discussions about LLMs, mute the channel if it’s too busy, but set notifications to
-   alert you only when “LLMs” appears in messages.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.1, available at
-[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
-
-Community Impact Guidelines were inspired by
-[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
-
-For answers to common questions about this code of conduct, see the FAQ at
-[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
-[https://www.contributor-covenant.org/translations][translations].
-
-[homepage]: https://www.contributor-covenant.org
-[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
-[Mozilla CoC]: https://github.com/mozilla/diversity
-[FAQ]: https://www.contributor-covenant.org/faq
-[translations]: https://www.contributor-covenant.org/translations

COMMUNITY.md

@@ -1,58 +0,0 @@
-# The OpenHands Community
-
-OpenHands is a community of engineers, academics, and enthusiasts reimagining software development for an AI-powered
-world.
-
-## Mission
-
-It’s very clear that AI is changing software development. We want the developer community to drive that change
-organically, through open source.
-
-So we’re not just building friendly interfaces for AI-driven development. We’re publishing _building blocks_ that
-empower developers to create new experiences, tailored to your own habits, needs, and imagination.
-
-## Ethos
-
-We have two core values: **high openness** and **high agency**. While we don’t expect everyone in the community to
-embody these values, we want to establish them as norms.
-
-### High Openness
-
-We welcome anyone and everyone into our community by default. You don’t have to be a software developer to help us
-build. You don’t have to be pro-AI to help us learn.
-
-Our plans, our work, our successes, and our failures are all public record. We want the world to see not just the
-fruits of our work, but the whole process of growing it.
-
-We welcome thoughtful criticism, whether it’s a comment on a PR or feedback on the community as a whole.
-
-### High Agency
-
-Everyone should feel empowered to contribute to OpenHands. Whether it’s by making a PR, hosting an event, sharing
-feedback, or just asking a question, don’t hold back!
-
-OpenHands gives everyone the building blocks to create state-of-the-art developer experiences. We experiment constantly
-and love building new things.
-
-Coding, development practices, and communities are changing rapidly. We won’t hesitate to change direction and make big bets.
-
-## Relationship to All Hands
-
-OpenHands is supported by the for-profit organization [All Hands AI, Inc](https://www.openhands.dev/).
-
-All Hands was founded by three of the first major contributors to OpenHands:
-
-- Xingyao Wang, a UIUC PhD candidate who got OpenHands to the top of the SWE-bench leaderboards
-- Graham Neubig, a CMU Professor who rallied the academic community around OpenHands
-- Robert Brennan, a software engineer who architected the user-facing features of OpenHands
-
-All Hands is an important part of the OpenHands ecosystem. We’ve raised over $20M--mainly to hire developers and
-researchers who can work on OpenHands full-time, and to provide them with expensive infrastructure. ([Join us!](https://allhandsai.applytojob.com/apply/))
-
-But we see OpenHands as much larger, and ultimately more important, than All Hands. When our financial responsibility
-to investors is at odds with our social responsibility to the community—as it inevitably will be, from time to time—we
-promise to navigate that conflict thoughtfully and transparently.
-
-At some point, we may transfer custody of OpenHands to an open source foundation. But for now,
-the [Benevolent Dictator approach](http://www.catb.org/~esr/writings/cathedral-bazaar/homesteading/ar01s16.html) helps us move forward with speed and intention. If we ever forget the
-“benevolent” part, please: fork us.

CONTRIBUTING.md

@@ -1,139 +0,0 @@
-# Contributing
-
-Thanks for your interest in contributing to OpenHands! We welcome and appreciate contributions.
-
-## Understanding OpenHands's CodeBase
-
-To understand the codebase, please refer to the README in each module:
-- [frontend](./frontend/README.md)
-- [openhands](./openhands/README.md)
-   - [agenthub](./openhands/agenthub/README.md)
-   - [server](./openhands/server/README.md)
-
-For benchmarks and evaluation, see the [OpenHands/benchmarks](https://github.com/OpenHands/benchmarks) repository.
-
-## Setting up Your Development Environment
-
-We have a separate doc [Development.md](https://github.com/OpenHands/OpenHands/blob/main/Development.md) that tells
-you how to set up a development workflow.
-
-## How Can I Contribute?
-
-There are many ways that you can contribute:
-
-1. **Download and use** OpenHands, and send [issues](https://github.com/OpenHands/OpenHands/issues) when you encounter something that isn't working or a feature that you'd like to see.
-2. **Send feedback** after each session by [clicking the thumbs-up thumbs-down buttons](https://docs.openhands.dev/usage/feedback), so we can see where things are working and failing, and also build an open dataset for training code agents.
-3. **Improve the Codebase** by sending [PRs](#sending-pull-requests-to-openhands) (see details below). In particular, we have some [good first issues](https://github.com/OpenHands/OpenHands/labels/good%20first%20issue) that may be ones to start on.
-
-## What Can I Build?
-
-Here are a few ways you can help improve the codebase.
-
-#### UI/UX
-
-We're always looking to improve the look and feel of the application. If you've got a small fix
-for something that's bugging you, feel free to open up a PR that changes the [`./frontend`](./frontend) directory.
-
-If you're looking to make a bigger change, add a new UI element, or significantly alter the style
-of the application, please open an issue first, or better, join the #dev-ui-ux channel in our Slack
-to gather consensus from our design team first.
-
-#### Improving the agent
-
-Our main agent is the CodeAct agent. You can [see its prompts here](https://github.com/OpenHands/OpenHands/tree/main/openhands/agenthub/codeact_agent).
-
-Changes to these prompts, and to the underlying behavior in Python, can have a huge impact on user experience.
-You can try modifying the prompts to see how they change the behavior of the agent as you use the app
-locally, but we will need to do an end-to-end evaluation of any changes here to ensure that the agent
-is getting better over time.
-
-We use the [SWE-bench](https://www.swebench.com/) benchmark to test our agent. You can join the #evaluation
-channel in Slack to learn more.
-
-#### Adding a new agent
-
-You may want to experiment with building new types of agents. You can add an agent to [`openhands/agenthub`](./openhands/agenthub)
-to help expand the capabilities of OpenHands.
-
-#### Adding a new runtime
-
-The agent needs a place to run code and commands. When you run OpenHands on your laptop, it uses a Docker container
-to do this by default. But there are other ways of creating a sandbox for the agent.
-
-If you work for a company that provides a cloud-based runtime, you could help us add support for that runtime
-by implementing the [interface specified here](https://github.com/OpenHands/OpenHands/blob/main/openhands/runtime/base.py).
-
-#### Testing
-
-When you write code, it is also good to write tests. Please navigate to the [`./tests`](./tests) folder to see existing
-test suites. At the moment, we have these kinds of tests: [`unit`](./tests/unit), [`runtime`](./tests/runtime), and [`end-to-end (e2e)`](./tests/e2e).
-Please refer to the README for each test suite. These tests also run on GitHub's continuous integration to ensure
-quality of the project.
-
-## Sending Pull Requests to OpenHands
-
-You'll need to fork our repository to send us a Pull Request. You can learn more
-about how to fork a GitHub repo and open a PR with your changes in [this article](https://medium.com/swlh/forks-and-pull-requests-how-to-contribute-to-github-repos-8843fac34ce8).
-
-### Pull Request title
-
-As described [here](https://github.com/commitizen/conventional-commit-types/blob/master/index.json), ideally a valid PR title should begin with one of the following prefixes:
-
-- `feat`: A new feature
-- `fix`: A bug fix
-- `docs`: Documentation only changes
-- `style`: Changes that do not affect the meaning of the code (white space, formatting, missing semicolons, etc.)
-- `refactor`: A code change that neither fixes a bug nor adds a feature
-- `perf`: A code change that improves performance
-- `test`: Adding missing tests or correcting existing tests
-- `build`: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
-- `ci`: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
-- `chore`: Other changes that don't modify src or test files
-- `revert`: Reverts a previous commit
-
-For example, a PR title could be:
-- `refactor: modify package path`
-- `feat(frontend): xxxx`, where `(frontend)` means that this PR mainly focuses on the frontend component.
-
-You may also check out previous PRs in the [PR list](https://github.com/OpenHands/OpenHands/pulls).
-
-### Pull Request description
-
-- If your PR is small (such as a typo fix), you can go brief.
-- If it contains a lot of changes, it's better to write more details.
-
-If your changes are user-facing (e.g. a new feature in the UI, a change in behavior, or a bugfix)
-please include a short message that we can add to our changelog.
-
-## How to Make Effective Contributions
-
-### Opening Issues
-
-If you notice any bugs or have any feature requests please open them via the [issues page](https://github.com/OpenHands/OpenHands/issues). We will triage
-based on how critical the bug is or how potentially useful the improvement is, discuss, and implement the ones that
-the community has interest/effort for.
-
-Further, if you see an issue you like, please leave a "thumbs-up" or a comment, which will help us prioritize.
-
-### Making Pull Requests
-
-We're generally happy to consider all pull requests with the evaluation process varying based on the type of change:
-
-#### For Small Improvements
-
-Small improvements with few downsides are typically reviewed and approved quickly.
-One thing to check when making changes is to ensure that all continuous integration tests pass, which you can check
-before getting a review.
-
-#### For Core Agent Changes
-
-We need to be more careful with changes to the core agent, as it is imperative to maintain high quality. These PRs are
-evaluated based on three key metrics:
-
-1. **Accuracy**
-2. **Efficiency**
-3. **Code Complexity**
-
-If it improves accuracy, efficiency, or both with only a minimal change to code quality, that's great we're happy to merge it in!
-If there are bigger tradeoffs (e.g. helping efficiency a lot and hurting accuracy a little) we might want to put it behind a feature flag.
-Either way, please feel free to discuss on github issues or slack, and we will give guidance and preliminary feedback.

CREDITS.md

@@ -1,328 +0,0 @@
-# Credits
-
-## Contributors
-
-We would like to thank all the [contributors](https://github.com/OpenHands/OpenHands/graphs/contributors) who have
-helped make OpenHands possible. We greatly appreciate your dedication and hard work.
-
-## Open Source Projects
-
-OpenHands includes and adapts the following open source projects. We are grateful for their contributions to the
-open source community:
-
-#### [SWE Agent](https://github.com/princeton-nlp/swe-agent)
-   - License: MIT License
-   - Description: Adapted for use in OpenHands's agent hub
-
-#### [Aider](https://github.com/paul-gauthier/aider)
-   - License: Apache License 2.0
-   - Description: AI pair programming tool. OpenHands has adapted and integrated its linter module for code-related tasks in [`agentskills utilities`](https://github.com/OpenHands/OpenHands/tree/main/openhands/runtime/plugins/agent_skills/utils/aider)
-
-#### [BrowserGym](https://github.com/ServiceNow/BrowserGym)
-   - License: Apache License 2.0
-   - Description: Adapted in implementing the browsing agent
-
-### Reference Implementations for Evaluation Benchmarks
-
-OpenHands integrates code of the reference implementations for the following agent evaluation benchmarks:
-
-#### [HumanEval](https://github.com/openai/human-eval)
-   - License: MIT License
-
-#### [DSP](https://github.com/microsoft/DataScienceProblems)
-   - License: MIT License
-
-#### [HumanEvalPack](https://github.com/bigcode-project/bigcode-evaluation-harness)
-   - License: Apache License 2.0
-
-#### [AgentBench](https://github.com/THUDM/AgentBench)
-   - License: Apache License 2.0
-
-#### [SWE-Bench](https://github.com/princeton-nlp/SWE-bench)
-   - License: MIT License
-
-#### [BIRD](https://bird-bench.github.io/)
-   - License: MIT License
-   - Dataset: CC-BY-SA 4.0
-
-#### [Gorilla APIBench](https://github.com/ShishirPatil/gorilla)
-   - License: Apache License 2.0
-
-#### [GPQA](https://github.com/idavidrein/gpqa)
-   - License: MIT License
-
-#### [ProntoQA](https://github.com/asaparov/prontoqa)
-   - License: Apache License 2.0
-
-## Open Source licenses
-
-### MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
-OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-### BSD 3-Clause License
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
-following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
-   disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
-   disclaimer in the documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
-   products derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-### Apache License 2.0
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-### Non-Open Source Reference Implementations:
-
-#### [MultiPL-E](https://github.com/nuprl/MultiPL-E)
-   - License: BSD 3-Clause License with Machine Learning Restriction
-
-BSD 3-Clause License with Machine Learning Restriction
-
-Copyright (c) 2022, Northeastern University, Oberlin College, Roblox Inc,
-Stevens Institute of Technology, University of Massachusetts Amherst, and
-Wellesley College.
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-4.  The contents of this repository may not be used as training data for any
-    machine learning model, including but not limited to neural networks.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Development.md

@@ -1,206 +0,0 @@
-# Development Guide
-
-This guide is for people working on OpenHands and editing the source code.
-If you wish to contribute your changes, check out the
-[CONTRIBUTING.md](https://github.com/OpenHands/OpenHands/blob/main/CONTRIBUTING.md)
-on how to clone and setup the project initially before moving on. Otherwise,
-you can clone the OpenHands project directly.
-
-## Start the Server for Development
-
-### 1. Requirements
-
-- Linux, Mac OS, or [WSL on Windows](https://learn.microsoft.com/en-us/windows/wsl/install) [Ubuntu >= 22.04]
-- [Docker](https://docs.docker.com/engine/install/) (For those on MacOS, make sure to allow the default Docker socket to be used from advanced settings!)
-- [Python](https://www.python.org/downloads/) = 3.12
-- [NodeJS](https://nodejs.org/en/download/package-manager) >= 22.x
-- [Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer) >= 1.8
-- OS-specific dependencies:
-  - Ubuntu: build-essential => `sudo apt-get install build-essential python3.12-dev`
-  - WSL: netcat => `sudo apt-get install netcat`
-
-Make sure you have all these dependencies installed before moving on to `make build`.
-
-#### Dev container
-
-There is a [dev container](https://containers.dev/) available which provides a
-pre-configured environment with all the necessary dependencies installed if you
-are using a [supported editor or tool](https://containers.dev/supporting). For
-example, if you are using Visual Studio Code (VS Code) with the
-[Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
-extension installed, you can open the project in a dev container by using the
-_Dev Container: Reopen in Container_ command from the Command Palette
-(Ctrl+Shift+P).
-
-#### Develop without sudo access
-
-If you want to develop without system admin/sudo access to upgrade/install `Python` and/or `NodeJS`, you can use
-`conda` or `mamba` to manage the packages for you:
-
-```bash
-# Download and install Mamba (a faster version of conda)
-curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
-bash Miniforge3-$(uname)-$(uname -m).sh
-
-# Install Python 3.12, nodejs, and poetry
-mamba install python=3.12
-mamba install conda-forge::nodejs
-mamba install conda-forge::poetry
-```
-
-### 2. Build and Setup The Environment
-
-Begin by building the project which includes setting up the environment and installing dependencies. This step ensures
-that OpenHands is ready to run on your system:
-
-```bash
-make build
-```
-
-### 3. Configuring the Language Model
-
-OpenHands supports a diverse array of Language Models (LMs) through the powerful [litellm](https://docs.litellm.ai) library.
-
-To configure the LM of your choice, run:
-
-```bash
-make setup-config
-```
-
-This command will prompt you to enter the LLM API key, model name, and other variables ensuring that OpenHands is
-tailored to your specific needs. Note that the model name will apply only when you run headless. If you use the UI,
-please set the model in the UI.
-
-Note: If you have previously run OpenHands using the docker command, you may have already set some environment
-variables in your terminal. The final configurations are set from highest to lowest priority:
-Environment variables > config.toml variables > default variables
-
-**Note on Alternative Models:**
-See [our documentation](https://docs.openhands.dev/usage/llms) for recommended models.
-
-### 4. Running the application
-
-#### Option A: Run the Full Application
-
-Once the setup is complete, this command starts both the backend and frontend servers, allowing you to interact with OpenHands:
-
-```bash
-make run
-```
-
-#### Option B: Individual Server Startup
-
-- **Start the Backend Server:** If you prefer, you can start the backend server independently to focus on
-  backend-related tasks or configurations.
-
-  ```bash
-  make start-backend
-  ```
-
-- **Start the Frontend Server:** Similarly, you can start the frontend server on its own to work on frontend-related
-  components or interface enhancements.
-  ```bash
-  make start-frontend
-  ```
-
-### 5. Running OpenHands with OpenHands
-
-You can use OpenHands to develop and improve OpenHands itself! This is a powerful way to leverage AI assistance for contributing to the project.
-
-#### Quick Start
-
-1. **Build and run OpenHands:**
-
-   ```bash
-   export INSTALL_DOCKER=0
-   export RUNTIME=local
-   make build && make run
-   ```
-
-2. **Access the interface:**
-
-   - Local development: http://localhost:3001
-   - Remote/cloud environments: Use the appropriate external URL
-
-3. **Configure for external access (if needed):**
-   ```bash
-   # For external access (e.g., cloud environments)
-   make run FRONTEND_PORT=12000 FRONTEND_HOST=0.0.0.0 BACKEND_HOST=0.0.0.0
-   ```
-
-### 6. LLM Debugging
-
-If you encounter any issues with the Language Model (LM) or you're simply curious, export DEBUG=1 in the environment and restart the backend.
-OpenHands will log the prompts and responses in the logs/llm/CURRENT_DATE directory, allowing you to identify the causes.
-
-### 7. Help
-
-Need help or info on available targets and commands? Use the help command for all the guidance you need with OpenHands.
-
-```bash
-make help
-```
-
-### 8. Testing
-
-To run tests, refer to the following:
-
-#### Unit tests
-
-```bash
-poetry run pytest ./tests/unit/test_*.py
-```
-
-### 9. Add or update dependency
-
-1. Add your dependency in `pyproject.toml` or use `poetry add xxx`.
-2. Update the poetry.lock file via `poetry lock --no-update`.
-
-### 10. Use existing Docker image
-
-To reduce build time (e.g., if no changes were made to the client-runtime component), you can use an existing Docker
-container image by setting the SANDBOX_RUNTIME_CONTAINER_IMAGE environment variable to the desired Docker image.
-
-Example: `export SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/openhands/runtime:1.2-nikolaik`
-
-## Develop inside Docker container
-
-TL;DR
-
-```bash
-make docker-dev
-```
-
-See more details [here](./containers/dev/README.md).
-
-If you are just interested in running `OpenHands` without installing all the required tools on your host.
-
-```bash
-make docker-run
-```
-
-If you do not have `make` on your host, run:
-
-```bash
-cd ./containers/dev
-./dev.sh
-```
-
-You do need [Docker](https://docs.docker.com/engine/install/) installed on your host though.
-
-## Key Documentation Resources
-
-Here's a guide to the important documentation files in the repository:
-
-- [/README.md](./README.md): Main project overview, features, and basic setup instructions
-- [/Development.md](./Development.md) (this file): Comprehensive guide for developers working on OpenHands
-- [/CONTRIBUTING.md](./CONTRIBUTING.md): Guidelines for contributing to the project, including code style and PR process
-- [DOC_STYLE_GUIDE.md](https://github.com/OpenHands/docs/blob/main/openhands/DOC_STYLE_GUIDE.md): Standards for writing and maintaining project documentation
-- [/openhands/README.md](./openhands/README.md): Details about the backend Python implementation
-- [/frontend/README.md](./frontend/README.md): Frontend React application setup and development guide
-- [/containers/README.md](./containers/README.md): Information about Docker containers and deployment
-- [/tests/unit/README.md](./tests/unit/README.md): Guide to writing and running unit tests
-- [OpenHands/benchmarks](https://github.com/OpenHands/benchmarks): Documentation for the evaluation framework and benchmarks
-- [/skills/README.md](./skills/README.md): Information about the skills architecture and implementation
-- [/openhands/server/README.md](./openhands/server/README.md): Server implementation details and API documentation
-- [/openhands/runtime/README.md](./openhands/runtime/README.md): Documentation for the runtime environment and execution model

ISSUE_TRIAGE.md

@@ -1,27 +0,0 @@
-# Issue Triage
-These are the procedures and guidelines on how issues are triaged in this repo by the maintainers.
-
-## General
-* All issues must be tagged with **enhancement**, **bug** or **troubleshooting/help**.
-* Issues may be tagged with what it relates to (**llm**, **app tab**, **UI/UX**, etc.).
-
-## Severity
-* **High**: High visibility issues or affecting many users.
-* **Critical**: Affecting all users or potential security issues.
-
-## Difficulty
-* Issues good for newcomers may be tagged with **good first issue**.
-
-## Not Enough Information
-* User is asked to provide more information (logs, how to reproduce, etc.) when the issue is not clear.
-* If an issue is unclear and the author does not provide more information or respond to a request,
-the issue may be closed as **not planned** (Usually after a week).
-
-## Multiple Requests/Fixes in One Issue
-* These issues will be narrowed down to one request/fix so the issue is more easily tracked and fixed.
-* Issues may be broken down into multiple issues if required.
-
-## Stale and Auto Closures
-* In order to keep a maintainable backlog, issues that have no activity within 40 days are automatically marked as **Stale**.
-* If issues marked as **Stale** continue to have no activity for 10 more days, they will automatically be closed as not planned.
-* Issues may be reopened by maintainers if deemed important.

LICENSE

@@ -1,30 +0,0 @@
-Portions of this software are licensed as follows:
-* All content that resides under the enterprise/ directory is licensed under the license defined in "enterprise/LICENSE".
-* Content outside of the above mentioned directories or restrictions above is available under the MIT license as defined below.
-
-=====================
-
-The MIT License (MIT)
-
-Copyright © 2025
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the “Software”), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.

MANIFEST.in

@@ -1,5 +0,0 @@
-# Exclude all Python bytecode files
-global-exclude *.pyc
-
-# Exclude Python cache directories
-global-exclude __pycache__

Makefile

@@ -1,371 +0,0 @@
-SHELL=/usr/bin/env bash
-# Makefile for OpenHands project
-
-# Variables
-BACKEND_HOST ?= "127.0.0.1"
-BACKEND_PORT ?= 3000
-BACKEND_HOST_PORT = "$(BACKEND_HOST):$(BACKEND_PORT)"
-FRONTEND_HOST ?= "127.0.0.1"
-FRONTEND_PORT ?= 3001
-DEFAULT_WORKSPACE_DIR = "./workspace"
-DEFAULT_MODEL = "gpt-4o"
-CONFIG_FILE = config.toml
-PRE_COMMIT_CONFIG_PATH = "./dev_config/python/.pre-commit-config.yaml"
-PYTHON_VERSION = 3.12
-KIND_CLUSTER_NAME = "local-hands"
-
-# ANSI color codes
-GREEN=$(shell tput -Txterm setaf 2)
-YELLOW=$(shell tput -Txterm setaf 3)
-RED=$(shell tput -Txterm setaf 1)
-BLUE=$(shell tput -Txterm setaf 6)
-RESET=$(shell tput -Txterm sgr0)
-
-# Build
-build:
-	@echo "$(GREEN)Building project...$(RESET)"
-	@$(MAKE) -s check-dependencies
-	@$(MAKE) -s install-python-dependencies
-	@$(MAKE) -s install-frontend-dependencies
-	@$(MAKE) -s install-pre-commit-hooks
-	@$(MAKE) -s build-frontend
-	@echo "$(GREEN)Build completed successfully.$(RESET)"
-
-check-dependencies:
-	@echo "$(YELLOW)Checking dependencies...$(RESET)"
-	@$(MAKE) -s check-system
-	@$(MAKE) -s check-python
-	@$(MAKE) -s check-npm
-	@$(MAKE) -s check-nodejs
-ifeq ($(INSTALL_DOCKER),)
-	@$(MAKE) -s check-docker
-endif
-	@$(MAKE) -s check-poetry
-	@$(MAKE) -s check-tmux
-	@echo "$(GREEN)Dependencies checked successfully.$(RESET)"
-
-check-system:
-	@echo "$(YELLOW)Checking system...$(RESET)"
-	@if [ "$(shell uname)" = "Darwin" ]; then \
-		echo "$(BLUE)macOS detected.$(RESET)"; \
-	elif [ "$(shell uname)" = "Linux" ]; then \
-		if [ -f "/etc/manjaro-release" ]; then \
-			echo "$(BLUE)Manjaro Linux detected.$(RESET)"; \
-		else \
-			echo "$(BLUE)Linux detected.$(RESET)"; \
-		fi; \
-	elif [ "$$(uname -r | grep -i microsoft)" ]; then \
-		echo "$(BLUE)Windows Subsystem for Linux detected.$(RESET)"; \
-	else \
-		echo "$(RED)Unsupported system detected. Please use macOS, Linux, or Windows Subsystem for Linux (WSL).$(RESET)"; \
-		exit 1; \
-	fi
-
-check-python:
-	@echo "$(YELLOW)Checking Python installation...$(RESET)"
-	@if command -v python$(PYTHON_VERSION) > /dev/null; then \
-		echo "$(BLUE)$(shell python$(PYTHON_VERSION) --version) is already installed.$(RESET)"; \
-	else \
-		echo "$(RED)Python $(PYTHON_VERSION) is not installed. Please install Python $(PYTHON_VERSION) to continue.$(RESET)"; \
-		exit 1; \
-	fi
-
-check-npm:
-	@echo "$(YELLOW)Checking npm installation...$(RESET)"
-	@if command -v npm > /dev/null; then \
-		echo "$(BLUE)npm $(shell npm --version) is already installed.$(RESET)"; \
-	else \
-		echo "$(RED)npm is not installed. Please install Node.js to continue.$(RESET)"; \
-		exit 1; \
-	fi
-
-check-nodejs:
-	@echo "$(YELLOW)Checking Node.js installation...$(RESET)"
-	@if command -v node > /dev/null; then \
-		NODE_VERSION=$(shell node --version | sed -E 's/v//g'); \
-		IFS='.' read -r -a NODE_VERSION_ARRAY <<< "$$NODE_VERSION"; \
-		if [ "$${NODE_VERSION_ARRAY[0]}" -ge 22 ]; then \
-			echo "$(BLUE)Node.js $$NODE_VERSION is already installed.$(RESET)"; \
-		else \
-			echo "$(RED)Node.js 22.x or later is required. Please install Node.js 22.x or later to continue.$(RESET)"; \
-			exit 1; \
-		fi; \
-	else \
-		echo "$(RED)Node.js is not installed. Please install Node.js to continue.$(RESET)"; \
-		exit 1; \
-	fi
-
-check-docker:
-	@echo "$(YELLOW)Checking Docker installation...$(RESET)"
-	@if command -v docker > /dev/null; then \
-		echo "$(BLUE)$(shell docker --version) is already installed.$(RESET)"; \
-	else \
-		echo "$(RED)Docker is not installed. Please install Docker to continue.$(RESET)"; \
-		exit 1; \
-	fi
-
-check-tmux:
-	@echo "$(YELLOW)Checking tmux installation...$(RESET)"
-	@if command -v tmux > /dev/null; then \
-		echo "$(BLUE)$(shell tmux -V) is already installed.$(RESET)"; \
-	else \
-		echo "$(YELLOW)╔════════════════════════════════════════════════════════════════════════════╗$(RESET)"; \
-		echo "$(YELLOW)║ OPTIONAL: tmux is not installed.                                          ║$(RESET)"; \
-		echo "$(YELLOW)║ Some advanced terminal features may not work without tmux.                ║$(RESET)"; \
-		echo "$(YELLOW)║ You can install it if needed, but it's not required for development.      ║$(RESET)"; \
-		echo "$(YELLOW)╚════════════════════════════════════════════════════════════════════════════╝$(RESET)"; \
-	fi
-
-check-poetry:
-	@echo "$(YELLOW)Checking Poetry installation...$(RESET)"
-	@if command -v poetry > /dev/null; then \
-		POETRY_VERSION=$(shell poetry --version 2>&1 | sed -E 's/Poetry \(version ([0-9]+\.[0-9]+\.[0-9]+)\)/\1/'); \
-		IFS='.' read -r -a POETRY_VERSION_ARRAY <<< "$$POETRY_VERSION"; \
-		if [ $${POETRY_VERSION_ARRAY[0]} -gt 1 ] || ([ $${POETRY_VERSION_ARRAY[0]} -eq 1 ] && [ $${POETRY_VERSION_ARRAY[1]} -ge 8 ]); then \
-			echo "$(BLUE)$(shell poetry --version) is already installed.$(RESET)"; \
-		else \
-			echo "$(RED)Poetry 1.8 or later is required. You can install poetry by running the following command, then adding Poetry to your PATH:"; \
-			echo "$(RED) curl -sSL https://install.python-poetry.org | python$(PYTHON_VERSION) -$(RESET)"; \
-			echo "$(RED)More detail here: https://python-poetry.org/docs/#installing-with-the-official-installer$(RESET)"; \
-			exit 1; \
-		fi; \
-	else \
-		echo "$(RED)Poetry is not installed. You can install poetry by running the following command, then adding Poetry to your PATH:"; \
-		echo "$(RED) curl -sSL https://install.python-poetry.org | python$(PYTHON_VERSION) -$(RESET)"; \
-		echo "$(RED)More detail here: https://python-poetry.org/docs/#installing-with-the-official-installer$(RESET)"; \
-		exit 1; \
-	fi
-
-install-python-dependencies:
-	@echo "$(GREEN)Installing Python dependencies...$(RESET)"
-	@if [ -z "${TZ}" ]; then \
-		echo "Defaulting TZ (timezone) to UTC"; \
-		export TZ="UTC"; \
-	fi
-	poetry env use python$(PYTHON_VERSION)
-	@if [ "$(shell uname)" = "Darwin" ]; then \
-		echo "$(BLUE)Installing chroma-hnswlib...$(RESET)"; \
-		export HNSWLIB_NO_NATIVE=1; \
-		poetry run pip install chroma-hnswlib; \
-	fi
-	@if [ -n "${POETRY_GROUP}" ]; then \
-		echo "Installing only POETRY_GROUP=${POETRY_GROUP}"; \
-		poetry install --only $${POETRY_GROUP}; \
-	else \
-		poetry install --with dev,test,runtime; \
-	fi
-	@if [ "${INSTALL_PLAYWRIGHT}" != "false" ] && [ "${INSTALL_PLAYWRIGHT}" != "0" ]; then \
-		if [ -f "/etc/manjaro-release" ]; then \
-			echo "$(BLUE)Detected Manjaro Linux. Installing Playwright dependencies...$(RESET)"; \
-			poetry run pip install playwright; \
-			poetry run playwright install chromium; \
-		else \
-			if [ ! -f cache/playwright_chromium_is_installed.txt ]; then \
-				echo "Running playwright install --with-deps chromium..."; \
-				poetry run playwright install --with-deps chromium; \
-				mkdir -p cache; \
-				touch cache/playwright_chromium_is_installed.txt; \
-			else \
-				echo "Setup already done. Skipping playwright installation."; \
-			fi \
-		fi \
-	else \
-		echo "Skipping Playwright installation (INSTALL_PLAYWRIGHT=${INSTALL_PLAYWRIGHT})."; \
-	fi
-	@echo "$(GREEN)Python dependencies installed successfully.$(RESET)"
-
-install-frontend-dependencies: check-npm check-nodejs
-	@echo "$(YELLOW)Setting up frontend environment...$(RESET)"
-	@echo "$(YELLOW)Detect Node.js version...$(RESET)"
-	@cd frontend && node ./scripts/detect-node-version.js
-	echo "$(BLUE)Installing frontend dependencies with npm...$(RESET)"
-	@cd frontend && npm install
-	@echo "$(GREEN)Frontend dependencies installed successfully.$(RESET)"
-
-install-pre-commit-hooks: check-python check-poetry install-python-dependencies
-	@echo "$(YELLOW)Installing pre-commit hooks...$(RESET)"
-	@git config --unset-all core.hooksPath || true
-	@poetry run pre-commit install --config $(PRE_COMMIT_CONFIG_PATH)
-	@echo "$(GREEN)Pre-commit hooks installed successfully.$(RESET)"
-
-lint-backend: install-pre-commit-hooks
-	@echo "$(YELLOW)Running linters...$(RESET)"
-	@poetry run pre-commit run --all-files --show-diff-on-failure --config $(PRE_COMMIT_CONFIG_PATH)
-
-lint-frontend: install-frontend-dependencies
-	@echo "$(YELLOW)Running linters for frontend...$(RESET)"
-	@cd frontend && npm run lint
-
-lint:
-	@$(MAKE) -s lint-frontend
-	@$(MAKE) -s lint-backend
-
-kind:
-	@echo "$(YELLOW)Checking if kind is installed...$(RESET)"
-	@if ! command -v kind > /dev/null; then \
-		echo "$(RED)kind is not installed. Please install kind with `brew install kind` to continue$(RESET)"; \
-		exit 1; \
-	else \
-		echo "$(BLUE)kind $(shell kind version) is already installed.$(RESET)"; \
-	fi
-	@echo "$(YELLOW)Checking if kind cluster '$(KIND_CLUSTER_NAME)' already exists...$(RESET)"
-	@if kind get clusters | grep -q "^$(KIND_CLUSTER_NAME)$$"; then \
-		echo "$(BLUE)Kind cluster '$(KIND_CLUSTER_NAME)' already exists.$(RESET)"; \
-		kubectl config use-context kind-$(KIND_CLUSTER_NAME); \
-	else \
-		echo "$(YELLOW)Creating kind cluster '$(KIND_CLUSTER_NAME)'...$(RESET)"; \
-		kind create cluster --name $(KIND_CLUSTER_NAME) --config kind/cluster.yaml; \
-	fi
-	@echo "$(YELLOW)Checking if mirrord is installed...$(RESET)"
-	@if ! command -v mirrord > /dev/null; then \
-		echo "$(RED)mirrord is not installed. Please install mirrord with `brew install metalbear-co/mirrord/mirrord` to continue$(RESET)"; \
-		exit 1; \
-	else \
-		echo "$(BLUE)mirrord $(shell mirrord --version) is already installed.$(RESET)"; \
-	fi
-	@echo "$(YELLOW)Installing k8s mirrord resources...$(RESET)"
-	@kubectl apply -f kind/manifests
-	@echo "$(GREEN)Mirrord resources installed successfully.$(RESET)"
-	@echo "$(YELLOW)Waiting for Mirrord pod to be ready.$(RESET)"
-	@sleep 5
-	@kubectl wait --for=condition=Available deployment/ubuntu-dev
-	@echo "$(YELLOW)Waiting for Nginx to be ready.$(RESET)"
-	@kubectl -n ingress-nginx wait --for=condition=Available deployment/ingress-nginx-controller
-	@echo "$(YELLOW)Running make run inside of mirrord.$(RESET)"
-	@mirrord exec --target deployment/ubuntu-dev -- make run
-
-test-frontend:
-	@echo "$(YELLOW)Running tests for frontend...$(RESET)"
-	@cd frontend && npm run test
-
-test:
-	@$(MAKE) -s test-frontend
-
-build-frontend:
-	@echo "$(YELLOW)Building frontend...$(RESET)"
-	@cd frontend && npm run prepare && npm run build
-
-# Start backend
-start-backend:
-	@echo "$(YELLOW)Starting backend...$(RESET)"
-	@poetry run uvicorn openhands.server.listen:app --host $(BACKEND_HOST) --port $(BACKEND_PORT) --reload --reload-exclude "./workspace"
-
-# Start frontend
-start-frontend:
-	@echo "$(YELLOW)Starting frontend...$(RESET)"
-	@cd frontend && \
-	if grep -qi microsoft /proc/version 2>/dev/null; then \
-		echo "Detected WSL environment. Using 'dev_wsl'"; \
-		SCRIPT=dev_wsl; \
-	else \
-		SCRIPT=dev; \
-	fi; \
-	VITE_BACKEND_HOST=$(BACKEND_HOST_PORT) VITE_FRONTEND_PORT=$(FRONTEND_PORT) npm run $$SCRIPT -- --port $(FRONTEND_PORT) --host $(BACKEND_HOST)
-
-# Common setup for running the app (non-callable)
-_run_setup:
-	@if [ "$(OS)" = "Windows_NT" ]; then \
-		echo "$(RED) Windows is not supported, use WSL instead!$(RESET)"; \
-		exit 1; \
-	fi
-	@mkdir -p logs
-	@echo "$(YELLOW)Starting backend server...$(RESET)"
-	@poetry run uvicorn openhands.server.listen:app --host $(BACKEND_HOST) --port $(BACKEND_PORT) &
-	@echo "$(YELLOW)Waiting for the backend to start...$(RESET)"
-	@until nc -z localhost $(BACKEND_PORT); do sleep 0.1; done
-	@echo "$(GREEN)Backend started successfully.$(RESET)"
-
-# Run the app (standard mode)
-run:
-	@echo "$(YELLOW)Running the app...$(RESET)"
-	@$(MAKE) -s _run_setup
-	@$(MAKE) -s start-frontend
-	@echo "$(GREEN)Application started successfully.$(RESET)"
-
-# Run the app (in docker)
-docker-run: WORKSPACE_BASE ?= $(PWD)/workspace
-docker-run:
-	@if [ -f /.dockerenv ]; then \
-		echo "Running inside a Docker container. Exiting..."; \
-		exit 0; \
-	else \
-		echo "$(YELLOW)Running the app in Docker $(OPTIONS)...$(RESET)"; \
-		export WORKSPACE_BASE=${WORKSPACE_BASE}; \
-		export SANDBOX_USER_ID=$(shell id -u); \
-		export DATE=$(shell date +%Y%m%d%H%M%S); \
-		docker compose up $(OPTIONS); \
-	fi
-
-
-# Setup config.toml
-setup-config:
-	@echo "$(YELLOW)Setting up config.toml...$(RESET)"
-	@$(MAKE) setup-config-prompts
-	@mv $(CONFIG_FILE).tmp $(CONFIG_FILE)
-	@echo "$(GREEN)Config.toml setup completed.$(RESET)"
-
-setup-config-prompts:
-	@echo "[core]" > $(CONFIG_FILE).tmp
-
-	@read -p "Enter your workspace directory (as absolute path) [default: $(DEFAULT_WORKSPACE_DIR)]: " workspace_dir; \
-	 workspace_dir=$${workspace_dir:-$(DEFAULT_WORKSPACE_DIR)}; \
-	 echo "workspace_base=\"$$workspace_dir\"" >> $(CONFIG_FILE).tmp
-
-	@echo "" >> $(CONFIG_FILE).tmp
-
-	@echo "[llm]" >> $(CONFIG_FILE).tmp
-	@read -p "Enter your LLM model name, used for running without UI. Set the model in the UI after you start the app. (see https://docs.litellm.ai/docs/providers for full list) [default: $(DEFAULT_MODEL)]: " llm_model; \
-	 llm_model=$${llm_model:-$(DEFAULT_MODEL)}; \
-	 echo "model=\"$$llm_model\"" >> $(CONFIG_FILE).tmp
-
-	@read -p "Enter your LLM api key: " llm_api_key; \
-	 echo "api_key=\"$$llm_api_key\"" >> $(CONFIG_FILE).tmp
-
-	@read -p "Enter your LLM base URL [mostly used for local LLMs, leave blank if not needed - example: http://localhost:5001/v1/]: " llm_base_url; \
-	 if [[ ! -z "$$llm_base_url" ]]; then echo "base_url=\"$$llm_base_url\"" >> $(CONFIG_FILE).tmp; fi
-
-setup-config-basic:
-	@printf '%s\n' \
-	'[core]' \
-	'workspace_base="./workspace"' \
-	> config.toml
-	@echo "$(GREEN)config.toml created.$(RESET)"
-
-openhands-cloud-run:
-	@$(MAKE) run BACKEND_HOST="0.0.0.0" BACKEND_PORT="12000" FRONTEND_HOST="0.0.0.0" FRONTEND_PORT="12001"
-
-# Develop in container
-docker-dev:
-	@if [ -f /.dockerenv ]; then \
-		echo "Running inside a Docker container. Exiting..."; \
-		exit 0; \
-	else \
-		echo "$(YELLOW)Build and run in Docker $(OPTIONS)...$(RESET)"; \
-		./containers/dev/dev.sh $(OPTIONS); \
-	fi
-
-# Clean up all caches
-clean:
-	@echo "$(YELLOW)Cleaning up caches...$(RESET)"
-	@rm -rf openhands/.cache
-	@echo "$(GREEN)Caches cleaned up successfully.$(RESET)"
-
-# Help
-help:
-	@echo "$(BLUE)Usage: make [target]$(RESET)"
-	@echo "Targets:"
-	@echo "  $(GREEN)build$(RESET)               - Build project, including environment setup and dependencies."
-	@echo "  $(GREEN)lint$(RESET)                - Run linters on the project."
-	@echo "  $(GREEN)setup-config$(RESET)        - Setup the configuration for OpenHands by providing LLM API key,"
-	@echo "                        LLM Model name, and workspace directory."
-	@echo "  $(GREEN)start-backend$(RESET)       - Start the backend server for the OpenHands project."
-	@echo "  $(GREEN)start-frontend$(RESET)      - Start the frontend server for the OpenHands project."
-	@echo "  $(GREEN)run$(RESET)                 - Run the OpenHands application, starting both backend and frontend servers."
-	@echo "                        Backend Log file will be stored in the 'logs' directory."
-	@echo "  $(GREEN)docker-dev$(RESET)          - Build and run the OpenHands application in Docker."
-	@echo "  $(GREEN)docker-run$(RESET)          - Run the OpenHands application, starting both backend and frontend servers in Docker."
-	@echo "  $(GREEN)help$(RESET)                - Display this help message, providing information on available targets."
-
-# Phony targets
-.PHONY: build check-dependencies check-system check-python check-npm check-nodejs check-docker check-poetry install-python-dependencies install-frontend-dependencies install-pre-commit-hooks lint-backend lint-frontend lint test-frontend test build-frontend start-backend start-frontend _run_setup run run-wsl setup-config setup-config-prompts setup-config-basic openhands-cloud-run docker-dev docker-run clean help
-.PHONY: kind

README.md

@@ -1,86 +0,0 @@
-<a name="readme-top"></a>
-
-<div align="center">
-  <img src="https://raw.githubusercontent.com/OpenHands/docs/main/openhands/static/img/logo.png" alt="Logo" width="200">
-  <h1 align="center" style="border-bottom: none">OpenHands: AI-Driven Development</h1>
-</div>
-
-
-<div align="center">
-  <a href="https://github.com/OpenHands/OpenHands/blob/main/LICENSE"><img src="https://img.shields.io/badge/LICENSE-MIT-20B2AA?style=for-the-badge" alt="MIT License"></a>
-  <a href="https://docs.google.com/spreadsheets/d/1wOUdFCMyY6Nt0AIqF705KN4JKOWgeI4wUGUP60krXXs/edit?gid=811504672#gid=811504672"><img src="https://img.shields.io/badge/SWEBench-77.6-00cc00?logoColor=FFE165&style=for-the-badge" alt="Benchmark Score"></a>
-  <br/>
-  <a href="https://docs.openhands.dev/sdk"><img src="https://img.shields.io/badge/Documentation-000?logo=googledocs&logoColor=FFE165&style=for-the-badge" alt="Check out the documentation"></a>
-  <a href="https://arxiv.org/abs/2511.03690"><img src="https://img.shields.io/badge/Paper-000?logoColor=FFE165&logo=arxiv&style=for-the-badge" alt="Tech Report"></a>
-
-
-  <!-- Keep these links. Translations will automatically update with the README. -->
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=de">Deutsch</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=es">Español</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=fr">français</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=ja">日本語</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=ko">한국어</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=pt">Português</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=ru">Русский</a> |
-  <a href="https://www.readme-i18n.com/OpenHands/OpenHands?lang=zh">中文</a>
-
-</div>
-
-<hr>
-
-🙌 Welcome to OpenHands, a [community](COMMUNITY.md) focused on AI-driven development. We’d love for you to [join us on Slack](https://dub.sh/openhands).
-
-There are a few ways to work with OpenHands:
-
-### OpenHands Software Agent SDK
-The SDK is a composable Python library that contains all of our agentic tech. It's the engine that powers everything else below.
-
-Define agents in code, then run them locally, or scale to 1000s of agents in the cloud.
-
-[Check out the docs](https://docs.openhands.dev/sdk) or [view the source](https://github.com/OpenHands/software-agent-sdk/)
-
-### OpenHands CLI
-The CLI is the easiest way to start using OpenHands. The experience will be familiar to anyone who has worked
-with e.g. Claude Code or Codex. You can power it with Claude, GPT, or any other LLM.
-
-[Check out the docs](https://docs.openhands.dev/openhands/usage/run-openhands/cli-mode) or [view the source](https://github.com/OpenHands/OpenHands-CLI)
-
-### OpenHands Local GUI
-Use the Local GUI for running agents on your laptop. It comes with a REST API and a single-page React application.
-The experience will be familiar to anyone who has used Devin or Jules.
-
-[Check out the docs](https://docs.openhands.dev/openhands/usage/run-openhands/local-setup) or view the source in this repo.
-
-### OpenHands Cloud
-This is a deployment of OpenHands GUI, running on hosted infrastructure.
-
-You can try it with a free $10 credit by [signing in with your GitHub or GitLab account](https://app.all-hands.dev).
-
-OpenHands Cloud comes with source-available features and integrations:
-- Integrations with Slack, Jira, and Linear
-- Multi-user support
-- RBAC and permissions
-- Collaboration features (e.g., conversation sharing)
-
-### OpenHands Enterprise
-Large enterprises can work with us to self-host OpenHands Cloud in their own VPC, via Kubernetes.
-OpenHands Enterprise can also work with the CLI and SDK above.
-
-OpenHands Enterprise is source-available--you can see all the source code here in the enterprise/ directory,
-but you'll need to purchase a license if you want to run it for more than one month.
-
-Enterprise contracts also come with extended support and access to our research team.
-
-Learn more at [openhands.dev/enterprise](https://openhands.dev/enterprise)
-
-### Everything Else
-
-Check out our [Product Roadmap](https://github.com/orgs/openhands/projects/1), and feel free to
-[open up an issue](https://github.com/OpenHands/OpenHands/issues) if there's something you'd like to see!
-
-You might also be interested in our [evaluation infrastructure](https://github.com/OpenHands/benchmarks), our [chrome extension](https://github.com/OpenHands/openhands-chrome-extension/), or our [Theory-of-Mind module](https://github.com/OpenHands/ToM-SWE).
-
-All our work is available under the MIT license, except for the `enterprise/` directory in this repository (see the [enterprise license](enterprise/LICENSE) for details).
-The core `openhands` and `agent-server` Docker images are fully MIT-licensed as well.
-
-If you need help with anything, or just want to chat, [come find us on Slack](https://dub.sh/openhands).

build.sh

@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-poetry build -v

code/openhands/runtime/action_execution_server.py

@@ -1,4 +1,5 @@
-"""This is the main file for the runtime client.
+"""
+This is the main file for the runtime client.
 It is responsible for executing actions received from OpenHands backend and producing observations.
 
 NOTE: this will be executed inside the docker sandbox.
@@ -7,18 +8,16 @@ NOTE: this will be executed inside the docker sandbox.
 import argparse
 import asyncio
 import base64
-import json
 import mimetypes
 import os
 import shutil
-import sys
 import tempfile
 import time
+import traceback
 from contextlib import asynccontextmanager
 from pathlib import Path
 from zipfile import ZipFile
 
-import puremagic
 from binaryornot.check import is_binary
 from fastapi import Depends, FastAPI, HTTPException, Request, UploadFile
 from fastapi.exceptions import RequestValidationError
@@ -33,9 +32,7 @@ from starlette.background import BackgroundTask
 from starlette.exceptions import HTTPException as StarletteHTTPException
 from uvicorn import run
 
-from openhands.core.config.mcp_config import MCPStdioServerConfig
 from openhands.core.exceptions import BrowserUnavailableException
-from openhands.core.logger import get_uvicorn_json_log_config
 from openhands.core.logger import openhands_logger as logger
 from openhands.events.action import (
     Action,
@@ -51,7 +48,6 @@ from openhands.events.event import FileEditSource, FileReadSource
 from openhands.events.observation import (
     CmdOutputObservation,
     ErrorObservation,
-    FileDownloadObservation,
     FileEditObservation,
     FileReadObservation,
     FileWriteObservation,
@@ -62,24 +58,16 @@ from openhands.events.serialization import event_from_dict, event_to_dict
 from openhands.runtime.browser import browse
 from openhands.runtime.browser.browser_env import BrowserEnv
 from openhands.runtime.file_viewer_server import start_file_viewer_server
-
-# Import our custom MCP Proxy Manager
-from openhands.runtime.mcp.proxy import MCPProxyManager
 from openhands.runtime.plugins import ALL_PLUGINS, JupyterPlugin, Plugin, VSCodePlugin
 from openhands.runtime.utils import find_available_tcp_port
+from openhands.runtime.utils.async_bash import AsyncBashSession
 from openhands.runtime.utils.bash import BashSession
 from openhands.runtime.utils.files import insert_lines, read_lines
 from openhands.runtime.utils.memory_monitor import MemoryMonitor
 from openhands.runtime.utils.runtime_init import init_user_and_working_directory
-from openhands.runtime.utils.system_stats import (
-    get_system_stats,
-    update_last_execution_time,
-)
+from openhands.runtime.utils.system_stats import get_system_stats
 from openhands.utils.async_utils import call_sync_from_async, wait_all
 
-if sys.platform == 'win32':
-    from openhands.runtime.utils.windows_bash import WindowsPowershellSession
-
 
 class ActionRequest(BaseModel):
     action: dict
@@ -105,7 +93,7 @@ def _execute_file_editor(
     view_range: list[int] | None = None,
     old_str: str | None = None,
     new_str: str | None = None,
-    insert_line: int | str | None = None,
+    insert_line: int | None = None,
     enable_linting: bool = False,
 ) -> tuple[str, tuple[str | None, str | None]]:
     """Execute file editor command and handle exceptions.
@@ -118,24 +106,13 @@ def _execute_file_editor(
         view_range: Optional view range tuple (start, end)
         old_str: Optional string to replace
         new_str: Optional replacement string
-        insert_line: Optional line number for insertion (can be int or str)
+        insert_line: Optional line number for insertion
         enable_linting: Whether to enable linting
 
     Returns:
         tuple: A tuple containing the output string and a tuple of old and new file content
     """
     result: ToolResult | None = None
-
-    # Convert insert_line from string to int if needed
-    if insert_line is not None and isinstance(insert_line, str):
-        try:
-            insert_line = int(insert_line)
-        except ValueError:
-            return (
-                f"ERROR:\nInvalid insert_line value: '{insert_line}'. Expected an integer.",
-                (None, None),
-            )
-
     try:
         result = editor(
             command=command,
@@ -149,9 +126,6 @@ def _execute_file_editor(
         )
     except ToolError as e:
         result = ToolResult(error=e.message)
-    except TypeError as e:
-        # Handle unexpected arguments or type errors
-        return f'ERROR:\n{str(e)}', (None, None)
 
     if result.error:
         return f'ERROR:\n{result.error}', (None, None)
@@ -174,7 +148,6 @@ class ActionExecutor:
         work_dir: str,
         username: str,
         user_id: int,
-        enable_browser: bool,
         browsergym_eval_env: str | None,
     ) -> None:
         self.plugins_to_load = plugins_to_load
@@ -187,25 +160,16 @@ class ActionExecutor:
         if _updated_user_id is not None:
             self.user_id = _updated_user_id
 
-        self.bash_session: BashSession | 'WindowsPowershellSession' | None = None  # type: ignore[name-defined]
+        self.bash_session: BashSession | None = None
         self.lock = asyncio.Lock()
         self.plugins: dict[str, Plugin] = {}
         self.file_editor = OHEditor(workspace_root=self._initial_cwd)
-        self.enable_browser = enable_browser
         self.browser: BrowserEnv | None = None
         self.browser_init_task: asyncio.Task | None = None
         self.browsergym_eval_env = browsergym_eval_env
-
-        if (not self.enable_browser) and self.browsergym_eval_env:
-            raise BrowserUnavailableException(
-                'Browser environment is not enabled in config, but browsergym_eval_env is set'
-            )
-
         self.start_time = time.time()
         self.last_execution_time = self.start_time
         self._initialized = False
-        self.downloaded_files: list[str] = []
-        self.downloads_directory = '/workspace/.downloads'
 
         self.max_memory_gb: int | None = None
         if _override_max_memory_gb := os.environ.get('RUNTIME_MAX_MEMORY_GB', None):
@@ -228,20 +192,12 @@ class ActionExecutor:
 
     async def _init_browser_async(self):
         """Initialize the browser asynchronously."""
-        if not self.enable_browser:
-            logger.info('Browser environment is not enabled in config')
-            return
-
-        if sys.platform == 'win32':
-            logger.warning('Browser environment not supported on windows')
-            return
-
         logger.debug('Initializing browser asynchronously')
         try:
             self.browser = BrowserEnv(self.browsergym_eval_env)
             logger.debug('Browser initialized asynchronously')
         except Exception as e:
-            logger.exception(f'Failed to initialize browser: {e}')
+            logger.error(f'Failed to initialize browser: {e}')
             self.browser = None
 
     async def _ensure_browser_ready(self):
@@ -266,32 +222,18 @@ class ActionExecutor:
         # If we get here, the browser is ready
         logger.debug('Browser is ready')
 
-    def _create_bash_session(self, cwd: str | None = None):
-        if sys.platform == 'win32':
-            return WindowsPowershellSession(  # type: ignore[name-defined]
-                work_dir=cwd or self._initial_cwd,
-                username=self.username,
-                no_change_timeout_seconds=int(
-                    os.environ.get('NO_CHANGE_TIMEOUT_SECONDS', 10)
-                ),
-                max_memory_mb=self.max_memory_gb * 1024 if self.max_memory_gb else None,
-            )
-        else:
-            bash_session = BashSession(
-                work_dir=cwd or self._initial_cwd,
-                username=self.username,
-                no_change_timeout_seconds=int(
-                    os.environ.get('NO_CHANGE_TIMEOUT_SECONDS', 10)
-                ),
-                max_memory_mb=self.max_memory_gb * 1024 if self.max_memory_gb else None,
-            )
-            bash_session.initialize()
-            return bash_session
-
     async def ainit(self):
         # bash needs to be initialized first
         logger.debug('Initializing bash session')
-        self.bash_session = self._create_bash_session()
+        self.bash_session = BashSession(
+            work_dir=self._initial_cwd,
+            username=self.username,
+            no_change_timeout_seconds=int(
+                os.environ.get('NO_CHANGE_TIMEOUT_SECONDS', 10)
+            ),
+            max_memory_mb=self.max_memory_gb * 1024 if self.max_memory_gb else None,
+        )
+        self.bash_session.initialize()
         logger.debug('Bash session initialized')
 
         # Start browser initialization in the background
@@ -300,7 +242,7 @@ class ActionExecutor:
 
         await wait_all(
             (self._init_plugin(plugin) for plugin in self.plugins_to_load),
-            timeout=int(os.environ.get('INIT_PLUGIN_TIMEOUT', '120')),
+            timeout=60,
         )
         logger.debug('All plugins initialized')
 
@@ -328,42 +270,24 @@ class ActionExecutor:
 
     async def _init_plugin(self, plugin: Plugin):
         assert self.bash_session is not None
-        # VSCode plugin needs runtime_id for path-based routing when using Gateway API
-        if isinstance(plugin, VSCodePlugin):
-            runtime_id = os.environ.get('RUNTIME_ID')
-            await plugin.initialize(self.username, runtime_id=runtime_id)
-        else:
-            await plugin.initialize(self.username)
+        await plugin.initialize(self.username)
         self.plugins[plugin.name] = plugin
         logger.debug(f'Initializing plugin: {plugin.name}')
 
         if isinstance(plugin, JupyterPlugin):
-            # Escape backslashes in Windows path
-            cwd = self.bash_session.cwd.replace('\\', '/')
             await self.run_ipython(
-                IPythonRunCellAction(code=f'import os; os.chdir(r"{cwd}")')
+                IPythonRunCellAction(
+                    code=f'import os; os.chdir("{self.bash_session.cwd}")'
+                )
             )
 
     async def _init_bash_commands(self):
-        # You can add any bash commands you want to run on startup here
-        # It is empty because: Git configuration is now handled by the runtime client after connection
-        INIT_COMMANDS = []
-        is_windows = sys.platform == 'win32'
-
-        # Determine no-pager command
-        if is_windows:
-            no_pager_cmd = 'function git { git.exe --no-pager $args }'
-        else:
-            no_pager_cmd = 'alias git="git --no-pager"'
-
-        INIT_COMMANDS.append(no_pager_cmd)
-
-        # Hack: for some reason when you set the openhands user to anything but root, tmux changes out
-        # of the mount directory on the first invocation.
-        if self.user_id != 0:
-            INIT_COMMANDS.append(f'cd {self._initial_cwd}')
-
-        logger.info(f'Initializing by running {len(INIT_COMMANDS)} bash commands...')
+        INIT_COMMANDS = [
+            'git config --file ./.git_config user.name "openhands" && git config --file ./.git_config user.email "openhands@all-hands.dev" && alias git="git --no-pager" && export GIT_CONFIG=$(pwd)/.git_config'
+            if os.environ.get('LOCAL_RUNTIME_MODE') == '1'
+            else 'git config --global user.name "openhands" && git config --global user.email "openhands@all-hands.dev" && alias git="git --no-pager"'
+        ]
+        logger.debug(f'Initializing by running {len(INIT_COMMANDS)} bash commands...')
         for command in INIT_COMMANDS:
             action = CmdRunAction(command=command)
             action.set_hard_timeout(300)
@@ -385,16 +309,19 @@ class ActionExecutor:
     async def run(
         self, action: CmdRunAction
     ) -> CmdOutputObservation | ErrorObservation:
-        try:
-            bash_session = self.bash_session
-            if action.is_static:
-                bash_session = self._create_bash_session(action.cwd)
-            assert bash_session is not None
-            obs = await call_sync_from_async(bash_session.execute, action)
+        if action.is_static:
+            path = action.cwd or self._initial_cwd
+            result = await AsyncBashSession.execute(action.command, path)
+            obs = CmdOutputObservation(
+                content=result.content,
+                exit_code=result.exit_code,
+                command=action.command,
+            )
             return obs
-        except Exception as e:
-            logger.exception(f'Error running command: {e}')
-            return ErrorObservation(str(e))
+
+        assert self.bash_session is not None
+        obs = await call_sync_from_async(self.bash_session.execute, action)
+        return obs
 
     async def run_ipython(self, action: IPythonRunCellAction) -> Observation:
         assert self.bash_session is not None
@@ -407,9 +334,9 @@ class ActionExecutor:
                 logger.debug(
                     f'{self.bash_session.cwd} != {jupyter_cwd} -> reset Jupyter PWD'
                 )
-                # escape windows paths
-                cwd = self.bash_session.cwd.replace('\\', '/')
-                reset_jupyter_cwd_code = f'import os; os.chdir("{cwd}")'
+                reset_jupyter_cwd_code = (
+                    f'import os; os.chdir("{self.bash_session.cwd}")'
+                )
                 _aux_action = IPythonRunCellAction(code=reset_jupyter_cwd_code)
                 _reset_obs: IPythonRunCellObservation = await _jupyter_plugin.run(
                     _aux_action
@@ -466,7 +393,7 @@ class ActionExecutor:
         filepath = self._resolve_path(action.path, working_dir)
         try:
             if filepath.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
-                with open(filepath, 'rb') as file:
+                with open(filepath, 'rb') as file:  # noqa: ASYNC101
                     image_data = file.read()
                     encoded_image = base64.b64encode(image_data).decode('utf-8')
                     mime_type, _ = mimetypes.guess_type(filepath)
@@ -476,13 +403,13 @@ class ActionExecutor:
 
                 return FileReadObservation(path=filepath, content=encoded_image)
             elif filepath.lower().endswith('.pdf'):
-                with open(filepath, 'rb') as file:
+                with open(filepath, 'rb') as file:  # noqa: ASYNC101
                     pdf_data = file.read()
                     encoded_pdf = base64.b64encode(pdf_data).decode('utf-8')
                     encoded_pdf = f'data:application/pdf;base64,{encoded_pdf}'
                 return FileReadObservation(path=filepath, content=encoded_pdf)
             elif filepath.lower().endswith(('.mp4', '.webm', '.ogg')):
-                with open(filepath, 'rb') as file:
+                with open(filepath, 'rb') as file:  # noqa: ASYNC101
                     video_data = file.read()
                     encoded_video = base64.b64encode(video_data).decode('utf-8')
                     mime_type, _ = mimetypes.guess_type(filepath)
@@ -492,7 +419,7 @@ class ActionExecutor:
 
                 return FileReadObservation(path=filepath, content=encoded_video)
 
-            with open(filepath, 'r', encoding='utf-8') as file:
+            with open(filepath, 'r', encoding='utf-8') as file:  # noqa: ASYNC101
                 lines = read_lines(file.readlines(), action.start, action.end)
         except FileNotFoundError:
             return ErrorObservation(
@@ -525,7 +452,7 @@ class ActionExecutor:
 
         mode = 'w' if not file_exists else 'r+'
         try:
-            with open(filepath, mode, encoding='utf-8') as file:
+            with open(filepath, mode, encoding='utf-8') as file:  # noqa: ASYNC101
                 if mode != 'w':
                     all_lines = file.readlines()
                     new_file = insert_lines(insert, all_lines, action.start, action.end)
@@ -589,58 +516,12 @@ class ActionExecutor:
         )
 
     async def browse(self, action: BrowseURLAction) -> Observation:
-        if self.browser is None:
-            return ErrorObservation(
-                'Browser functionality is not supported or disabled.'
-            )
         await self._ensure_browser_ready()
-        return await browse(action, self.browser, self.initial_cwd)
+        return await browse(action, self.browser)
 
     async def browse_interactive(self, action: BrowseInteractiveAction) -> Observation:
-        if self.browser is None:
-            return ErrorObservation(
-                'Browser functionality is not supported or disabled.'
-            )
         await self._ensure_browser_ready()
-        browser_observation = await browse(action, self.browser, self.initial_cwd)
-        if not browser_observation.error:
-            return browser_observation
-        else:
-            curr_files = os.listdir(self.downloads_directory)
-            new_download = False
-            for file in curr_files:
-                if file not in self.downloaded_files:
-                    new_download = True
-                    self.downloaded_files.append(file)
-                    break  # FIXME: assuming only one file will be downloaded for simplicity
-
-            if not new_download:
-                return browser_observation
-            else:
-                # A new file is downloaded in self.downloads_directory, shift file to /workspace
-                src_path = os.path.join(
-                    self.downloads_directory, self.downloaded_files[-1]
-                )
-                # Guess extension of file using puremagic and add it to tgt_path file name
-                file_ext = ''
-                try:
-                    guesses = puremagic.magic_file(src_path)
-                    if len(guesses) > 0:
-                        ext = guesses[0].extension.strip()
-                        if len(ext) > 0:
-                            file_ext = ext
-                except Exception as _:
-                    pass
-
-                tgt_path = os.path.join(
-                    '/workspace', f'file_{len(self.downloaded_files)}{file_ext}'
-                )
-                shutil.copy(src_path, tgt_path)
-                file_download_obs = FileDownloadObservation(
-                    content=f'Execution of the previous action {action.browser_actions} resulted in a file download. The downloaded file is saved at location: {tgt_path}',
-                    file_path=tgt_path,
-                )
-                return file_download_obs
+        return await browse(action, self.browser)
 
     def close(self):
         self.memory_monitor.stop_monitoring()
@@ -652,6 +533,7 @@ class ActionExecutor:
 
 if __name__ == '__main__':
     logger.warning('Starting Action Execution Server')
+
     parser = argparse.ArgumentParser()
     parser.add_argument('port', type=int, help='Port to listen on')
     parser.add_argument('--working-dir', type=str, help='Working directory')
@@ -660,12 +542,6 @@ if __name__ == '__main__':
         '--username', type=str, help='User to run as', default='openhands'
     )
     parser.add_argument('--user-id', type=int, help='User ID to run as', default=1000)
-    parser.add_argument(
-        '--enable-browser',
-        action=argparse.BooleanOptionalAction,
-        default=True,
-        help='Enable the browser environment',
-    )
     parser.add_argument(
         '--browsergym-eval-env',
         type=str,
@@ -679,7 +555,7 @@ if __name__ == '__main__':
     # Start the file viewer server in a separate thread
     logger.info('Starting file viewer server')
     _file_viewer_port = find_available_tcp_port(
-        min_port=args.port + 1, max_port=min(args.port + 1024, 65535)
+        min_port=args.port + 1, max_port=min(65535, args.port + 10000)
     )
     server_url, _ = start_file_viewer_server(port=_file_viewer_port)
     logger.info(f'File viewer server started at {server_url}')
@@ -692,67 +568,21 @@ if __name__ == '__main__':
             plugins_to_load.append(ALL_PLUGINS[plugin]())  # type: ignore
 
     client: ActionExecutor | None = None
-    mcp_proxy_manager: MCPProxyManager | None = None
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):
-        global client, mcp_proxy_manager
-        logger.info('Initializing ActionExecutor...')
+        global client
         client = ActionExecutor(
             plugins_to_load,
             work_dir=args.working_dir,
             username=args.username,
             user_id=args.user_id,
-            enable_browser=args.enable_browser,
             browsergym_eval_env=args.browsergym_eval_env,
         )
         await client.ainit()
-        logger.info('ActionExecutor initialized.')
-
-        # Check if we're on Windows
-        is_windows = sys.platform == 'win32'
-
-        # Initialize and mount MCP Proxy Manager (skip on Windows)
-        if is_windows:
-            logger.info('Skipping MCP Proxy initialization on Windows')
-            mcp_proxy_manager = None
-        else:
-            logger.info('Initializing MCP Proxy Manager...')
-            # Create a MCP Proxy Manager
-            mcp_proxy_manager = MCPProxyManager(
-                auth_enabled=bool(SESSION_API_KEY),
-                api_key=SESSION_API_KEY,
-                logger_level=logger.getEffectiveLevel(),
-            )
-            mcp_proxy_manager.initialize()
-            # Mount the proxy to the app
-            allowed_origins = ['*']
-            try:
-                await mcp_proxy_manager.mount_to_app(app, allowed_origins)
-            except Exception as e:
-                logger.error(f'Error mounting MCP Proxy: {e}', exc_info=True)
-                raise RuntimeError(f'Cannot mount MCP Proxy: {e}')
-
         yield
-
         # Clean up & release the resources
-        logger.info('Shutting down MCP Proxy Manager...')
-        if mcp_proxy_manager:
-            del mcp_proxy_manager
-            mcp_proxy_manager = None
-        else:
-            logger.info('MCP Proxy Manager instance not found for shutdown.')
-
-        logger.info('Closing ActionExecutor...')
-        if client:
-            try:
-                client.close()
-                logger.info('ActionExecutor closed successfully.')
-            except Exception as e:
-                logger.error(f'Error closing ActionExecutor: {e}', exc_info=True)
-        else:
-            logger.info('ActionExecutor instance not found for closing.')
-        logger.info('Shutdown complete.')
+        client.close()
 
     app = FastAPI(lifespan=lifespan)
 
@@ -768,14 +598,14 @@ if __name__ == '__main__':
 
     @app.exception_handler(StarletteHTTPException)
     async def http_exception_handler(request: Request, exc: StarletteHTTPException):
-        logger.exception(f'HTTP exception occurred: {exc.detail}')
+        logger.error(f'HTTP exception occurred: {exc.detail}')
         return JSONResponse(status_code=exc.status_code, content={'detail': exc.detail})
 
     @app.exception_handler(RequestValidationError)
     async def validation_exception_handler(
         request: Request, exc: RequestValidationError
     ):
-        logger.exception(f'Validation error occurred: {exc}')
+        logger.error(f'Validation error occurred: {exc}')
         return JSONResponse(
             status_code=422,
             content={
@@ -819,75 +649,19 @@ if __name__ == '__main__':
             if not isinstance(action, Action):
                 raise HTTPException(status_code=400, detail='Invalid action type')
             client.last_execution_time = time.time()
+
             observation = await client.run_action(action)
             return event_to_dict(observation)
         except Exception as e:
-            logger.exception(f'Error while running /execute_action: {str(e)}')
+            logger.error(f'Error while running /execute_action: {str(e)}')
             raise HTTPException(
                 status_code=500,
-                detail=f'Internal server error: {str(e)}',
+                detail=traceback.format_exc(),
             )
-        finally:
-            update_last_execution_time()
-
-    @app.post('/update_mcp_server')
-    async def update_mcp_server(request: Request):
-        # Check if we're on Windows
-        is_windows = sys.platform == 'win32'
-
-        # Access the global mcp_proxy_manager variable
-        global mcp_proxy_manager
-
-        if is_windows:
-            # On Windows, just return a success response without doing anything
-            logger.info(
-                'MCP server update request received on Windows - skipping as MCP is disabled'
-            )
-            return JSONResponse(
-                status_code=200,
-                content={
-                    'detail': 'MCP server update skipped (MCP is disabled on Windows)',
-                    'router_error_log': '',
-                },
-            )
-
-        # Non-Windows implementation
-        if mcp_proxy_manager is None:
-            raise HTTPException(
-                status_code=500, detail='MCP Proxy Manager is not initialized'
-            )
-
-        # Get the request body
-        mcp_tools_to_sync = await request.json()
-        if not isinstance(mcp_tools_to_sync, list):
-            raise HTTPException(
-                status_code=400, detail='Request must be a list of MCP tools to sync'
-            )
-        logger.info(
-            f'Updating MCP server with tools: {json.dumps(mcp_tools_to_sync, indent=2)}'
-        )
-        mcp_tools_to_sync = [MCPStdioServerConfig(**tool) for tool in mcp_tools_to_sync]
-        try:
-            await mcp_proxy_manager.update_and_remount(app, mcp_tools_to_sync, ['*'])
-            logger.info('MCP Proxy Manager updated and remounted successfully')
-            router_error_log = ''
-        except Exception as e:
-            logger.error(f'Error updating MCP Proxy Manager: {e}', exc_info=True)
-            router_error_log = str(e)
-
-        return JSONResponse(
-            status_code=200,
-            content={
-                'detail': 'MCP server updated successfully',
-                'router_error_log': router_error_log,
-            },
-        )
 
     @app.post('/upload_file')
     async def upload_file(
-        file: UploadFile,
-        destination: str = '/',
-        recursive: bool = False,
+        file: UploadFile, destination: str = '/', recursive: bool = False
     ):
         assert client is not None
 
@@ -910,7 +684,7 @@ if __name__ == '__main__':
                     )
 
                 zip_path = os.path.join(full_dest_path, file.filename)
-                with open(zip_path, 'wb') as buffer:
+                with open(zip_path, 'wb') as buffer:  # noqa: ASYNC101
                     shutil.copyfileobj(file.file, buffer)
 
                 # Extract the zip file
@@ -923,7 +697,7 @@ if __name__ == '__main__':
             else:
                 # For single file uploads
                 file_path = os.path.join(full_dest_path, file.filename)
-                with open(file_path, 'wb') as buffer:
+                with open(file_path, 'wb') as buffer:  # noqa: ASYNC101
                     shutil.copyfileobj(file.file, buffer)
                 logger.debug(f'Uploaded file {file.filename} to {destination}')
 
@@ -1001,7 +775,7 @@ if __name__ == '__main__':
 
         To list files:
         ```sh
-        curl -X POST -d '{"path": "/"}' http://localhost:3000/list_files
+        curl http://localhost:3000/api/list-files
         ```
 
         Args:
@@ -1030,12 +804,12 @@ if __name__ == '__main__':
 
         if not os.path.exists(full_path):
             # if user just removed a folder, prevent server error 500 in UI
-            return JSONResponse(content=[])
+            return []
 
         try:
             # Check if the directory exists
             if not os.path.exists(full_path) or not os.path.isdir(full_path):
-                return JSONResponse(content=[])
+                return []
 
             entries = os.listdir(full_path)
 
@@ -1064,15 +838,11 @@ if __name__ == '__main__':
 
             # Combine sorted directories and files
             sorted_entries = directories + files
-            return JSONResponse(content=sorted_entries)
+            return sorted_entries
 
         except Exception as e:
-            logger.exception(f'Error listing files: {e}')
-            return JSONResponse(content=[])
+            logger.error(f'Error listing files: {e}')
+            return []
 
     logger.debug(f'Starting action execution API on port {args.port}')
-    # When LOG_JSON=1, provide a JSON log config to Uvicorn so error/access logs are structured
-    log_config = None
-    if os.getenv('LOG_JSON', '0') in ('1', 'true', 'True'):
-        log_config = get_uvicorn_json_log_config()
-    run(app, host='0.0.0.0', port=args.port, log_config=log_config, use_colors=False)
+    run(app, host='0.0.0.0', port=args.port)

code/openhands/runtime/utils/system.py

@@ -28,6 +28,10 @@ def find_available_tcp_port(
     Returns:
         int: An available port number, or -1 if none found after max_attempts
     """
+    # Ensure ports are within valid range (0-65535)
+    min_port = max(0, min(min_port, 65535))
+    max_port = max(min_port, min(max_port, 65535))
+    
     rng = random.SystemRandom()
     ports = list(range(min_port, max_port + 1))
     rng.shuffle(ports)

config.template.toml

@@ -1,536 +0,0 @@
-###################### OpenHands Configuration Example ######################
-#
-# All settings have default values, so you only need to uncomment and
-# modify what you want to change
-# The fields within each section are sorted in alphabetical order.
-#
-##############################################################################
-
-#################################### Core ####################################
-# General core configurations
-##############################################################################
-[core]
-# API keys and configuration for core services
-
-# Base path for the workspace
-#workspace_base = "./workspace"
-
-# Cache directory path
-#cache_dir = "/tmp/cache"
-
-# Debugging enabled
-#debug = false
-
-# Disable color in terminal output
-#disable_color = false
-
-# Path to store trajectories, can be a folder or a file
-# If it's a folder, the session id will be used as the file name
-#save_trajectory_path="./trajectories"
-
-# Whether to save screenshots in the trajectory
-# The screenshots are encoded and can make trajectory json files very large
-#save_screenshots_in_trajectory = false
-
-# Path to replay a trajectory, must be a file path
-# If provided, trajectory will be loaded and replayed before the
-# agent responds to any user instruction
-#replay_trajectory_path = ""
-
-# File store path
-#file_store_path = "/tmp/file_store"
-
-# File store type
-#file_store = "memory"
-
-# Maximum file size for uploads, in megabytes
-#file_uploads_max_file_size_mb = 0
-
-# Enable the browser environment
-#enable_browser = true
-
-# Maximum budget per task, 0.0 means no limit
-#max_budget_per_task = 0.0
-
-# Maximum number of iterations
-#max_iterations = 500
-
-# Path to mount the workspace in the sandbox
-#workspace_mount_path_in_sandbox = "/workspace"
-
-# Path to mount the workspace
-#workspace_mount_path = ""
-
-# Path to rewrite the workspace mount path to
-#workspace_mount_rewrite = ""
-
-# Run as openhands
-#run_as_openhands = true
-
-# Runtime environment
-#runtime = "docker"
-
-# Name of the default agent
-#default_agent = "CodeActAgent"
-
-# JWT secret for authentication
-#jwt_secret = ""
-
-# Restrict file types for file uploads
-#file_uploads_restrict_file_types = false
-
-# List of allowed file extensions for uploads
-#file_uploads_allowed_extensions = [".*"]
-
-# Whether to enable the default LLM summarizing condenser when no condenser is specified in config
-# When true, a LLMSummarizingCondenserConfig will be used as the default condenser
-# When false, a NoOpCondenserConfig (no summarization) will be used
-#enable_default_condenser = true
-
-# Maximum number of concurrent conversations per user
-#max_concurrent_conversations = 3
-
-# Maximum age of conversations in seconds before they are automatically closed
-#conversation_max_age_seconds = 864000  # 10 days
-
-#################################### LLM #####################################
-# Configuration for LLM models (group name starts with 'llm')
-# use 'llm' for the default LLM config
-##############################################################################
-[llm]
-# AWS access key ID
-#aws_access_key_id = ""
-
-# AWS region name
-#aws_region_name = ""
-
-# AWS secret access key
-#aws_secret_access_key = ""
-
-# API key to use (For Headless / CLI only -  In Web this is overridden by Session Init)
-api_key = ""
-
-# API base URL (For Headless / CLI only -  In Web this is overridden by Session Init)
-#base_url = ""
-
-# API version
-#api_version = ""
-
-# Reasoning effort for OpenAI o-series models (low, medium, high, or not set)
-#reasoning_effort = "medium"
-
-# Cost per input token
-#input_cost_per_token = 0.0
-
-# Cost per output token
-#output_cost_per_token = 0.0
-
-# Custom LLM provider
-#custom_llm_provider = ""
-
-# Maximum number of characters in an observation's content
-#max_message_chars = 10000
-
-# Maximum number of input tokens
-#max_input_tokens = 0
-
-# Maximum number of output tokens
-#max_output_tokens = 0
-
-# Model to use. (For Headless / CLI only -  In Web this is overridden by Session Init)
-model = "gpt-4o"
-
-# Number of retries to attempt when an operation fails with the LLM.
-# Increase this value to allow more attempts before giving up
-#num_retries = 8
-
-# Maximum wait time (in seconds) between retry attempts
-# This caps the exponential backoff to prevent excessively long
-#retry_max_wait = 120
-
-# Minimum wait time (in seconds) between retry attempts
-# This sets the initial delay before the first retry
-#retry_min_wait = 15
-
-# Multiplier for exponential backoff calculation
-# The wait time increases by this factor after each failed attempt
-# A value of 2.0 means each retry waits twice as long as the previous one
-#retry_multiplier = 2.0
-
-# Drop any unmapped (unsupported) params without causing an exception
-#drop_params = false
-
-# Modify params for litellm to do transformations like adding a default message, when a message is empty.
-# Note: this setting is global, unlike drop_params, it cannot be overridden in each call to litellm.
-#modify_params = true
-
-# Using the prompt caching feature if provided by the LLM and supported
-#caching_prompt = true
-
-# Base URL for the OLLAMA API
-#ollama_base_url = ""
-
-# Temperature for the API
-#temperature = 0.0
-
-# Timeout for the API
-#timeout = 0
-
-# Top p for the API
-#top_p = 1.0
-
-# If model is vision capable, this option allows to disable image processing (useful for cost reduction).
-#disable_vision = true
-
-# Custom tokenizer to use for token counting
-# https://docs.litellm.ai/docs/completion/token_usage
-#custom_tokenizer = ""
-
-# Whether to use native tool calling if supported by the model. Can be true, false, or None by default, which chooses the model's default behavior based on the evaluation.
-# ATTENTION: Based on evaluation, enabling native function calling may lead to worse results
-# in some scenarios. Use with caution and consider testing with your specific use case.
-# https://github.com/OpenHands/OpenHands/pull/4711
-#native_tool_calling = None
-
-
-# Safety settings for models that support them (e.g., Mistral AI, Gemini)
-# Example for Mistral AI:
-# safety_settings = [
-#   { "category" = "hate", "threshold" = "low" },
-#   { "category" = "harassment", "threshold" = "low" },
-#   { "category" = "sexual", "threshold" = "low" },
-#   { "category" = "dangerous", "threshold" = "low" }
-# ]
-#
-# Example for Gemini:
-# safety_settings = [
-#   { "category" = "HARM_CATEGORY_HARASSMENT", "threshold" = "BLOCK_NONE" },
-#   { "category" = "HARM_CATEGORY_HATE_SPEECH", "threshold" = "BLOCK_NONE" },
-#   { "category" = "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold" = "BLOCK_NONE" },
-#   { "category" = "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold" = "BLOCK_NONE" }
-# ]
-#safety_settings = []
-
-[llm.draft_editor]
-# The number of times llm_editor tries to fix an error when editing.
-correct_num = 5
-
-[llm.gpt4o-mini]
-api_key = ""
-model = "gpt-4o"
-
-# Example routing LLM configuration for multimodal model routing
-# Uncomment and configure to enable model routing with a secondary model
-#[llm.secondary_model]
-#model = "kimi-k2"
-#api_key = ""
-#for_routing = true
-#max_input_tokens = 128000
-
-
-#################################### Agent ###################################
-# Configuration for agents (group name starts with 'agent')
-# Use 'agent' for the default agent config
-# otherwise, group name must be `agent.<agent_name>` (case-sensitive), e.g.
-# agent.CodeActAgent
-##############################################################################
-[agent]
-
-# Whether the browsing tool is enabled
-# Note: when this is set to true, enable_browser in the core config must also be true
-enable_browsing = true
-
-# Whether the LLM draft editor is enabled
-enable_llm_editor = false
-
-# Whether the standard editor tool (str_replace_editor) is enabled
-# Only has an effect if enable_llm_editor is False
-enable_editor = true
-
-# Whether the IPython tool is enabled
-enable_jupyter = true
-
-# Whether the command tool is enabled
-enable_cmd = true
-
-# Whether the think tool is enabled
-enable_think = true
-
-# Whether the finish tool is enabled
-enable_finish = true
-
-# LLM config group to use
-#llm_config = 'your-llm-config-group'
-
-# Whether to use prompt extension (e.g., microagent, repo/runtime info) at all
-#enable_prompt_extensions = true
-
-# List of microagents to disable
-#disabled_microagents = []
-
-# Whether history should be truncated to continue the session when hitting LLM context
-# length limit
-enable_history_truncation = true
-
-# Whether the condensation request tool is enabled
-enable_condensation_request = false
-
-[agent.RepoExplorerAgent]
-# Example: use a cheaper model for RepoExplorerAgent to reduce cost, especially
-# useful when an agent doesn't demand high quality but uses a lot of tokens
-llm_config = 'gpt3'
-
-[agent.CustomAgent]
-# Example: use a custom agent from a different package
-# This will be automatically be registered as a new agent named "CustomAgent"
-classpath = "my_package.my_module.MyCustomAgent"
-
-#################################### Sandbox ###################################
-# Configuration for the sandbox
-##############################################################################
-[sandbox]
-# Sandbox timeout in seconds
-#timeout = 120
-
-# Sandbox user ID
-#user_id = 1000
-
-# Container image to use for the sandbox
-#base_container_image = "nikolaik/python-nodejs:python3.12-nodejs22"
-
-# Use host network
-#use_host_network = false
-
-# Runtime extra build args
-#runtime_extra_build_args = ["--network=host", "--add-host=host.docker.internal:host-gateway"]
-
-# Enable auto linting after editing
-#enable_auto_lint = false
-
-# Whether to initialize plugins
-#initialize_plugins = true
-
-# Extra dependencies to install in the runtime image
-#runtime_extra_deps = ""
-
-# Environment variables to set at the launch of the runtime
-#runtime_startup_env_vars = {}
-
-# BrowserGym environment to use for evaluation
-#browsergym_eval_env = ""
-
-# Platform to use for building the runtime image (e.g., "linux/amd64")
-#platform = ""
-
-# Force rebuild of runtime image even if it exists
-#force_rebuild_runtime = false
-
-# Runtime container image to use (if not provided, will be built from base_container_image)
-#runtime_container_image = ""
-
-# Keep runtime alive after session ends
-#keep_runtime_alive = false
-
-# Pause closed runtimes instead of stopping them
-#pause_closed_runtimes = false
-
-# Delay in seconds before closing idle runtimes
-#close_delay = 300
-
-# Remove all containers when stopping the runtime
-#rm_all_containers = false
-
-# Enable GPU support in the runtime
-#enable_gpu = false
-
-# When there are multiple cards, you can specify the GPU by ID
-#cuda_visible_devices = ''
-
-# Additional Docker runtime kwargs
-#docker_runtime_kwargs = {}
-
-# Specific port to use for VSCode. If not set, a random port will be chosen.
-# Useful when deploying OpenHands in a remote machine where you need to expose a specific port.
-#vscode_port = 41234
-
-# Volume mounts in the format 'host_path:container_path[:mode]'
-# e.g. '/my/host/dir:/workspace:rw'
-# Multiple mounts can be specified using commas
-# e.g. '/path1:/workspace/path1,/path2:/workspace/path2:ro'
-
-# Configure volumes under the [sandbox] section:
-# [sandbox]
-# volumes = "/my/host/dir:/workspace:rw,/path2:/workspace/path2:ro"
-
-#################################### Security ###################################
-# Configuration for security features
-##############################################################################
-[security]
-
-# Enable confirmation mode (For Headless / CLI only -  In Web this is overridden by Session Init)
-#confirmation_mode = false
-
-# The security analyzer to use (For Headless / CLI only -  In Web this is overridden by Session Init)
-# Available options: 'llm' (default), 'invariant'
-#security_analyzer = "llm"
-
-# Whether to enable security analyzer
-#enable_security_analyzer = true
-
-#################################### Condenser #################################
-# Condensers control how conversation history is managed and compressed when
-# the context grows too large. Each agent uses one condenser configuration.
-##############################################################################
-[condenser]
-# The type of condenser to use. Available options:
-# - "noop": No condensing, keeps full history (default)
-# - "observation_masking": Keeps full event structure but masks older observations
-# - "recent": Keeps only recent events and discards older ones
-# - "llm": Uses an LLM to summarize conversation history
-# - "amortized": Intelligently forgets older events while preserving important context
-# - "llm_attention": Uses an LLM to prioritize most relevant context
-type = "noop"
-
-# Examples for each condenser type (uncomment and modify as needed):
-
-# 1. NoOp Condenser - No additional settings needed
-#type = "noop"
-
-# 2. Observation Masking Condenser
-#type = "observation_masking"
-# Number of most-recent events where observations will not be masked
-#attention_window = 100
-
-# 3. Recent Events Condenser
-#type = "recent"
-# Number of initial events to always keep (typically includes task description)
-#keep_first = 1
-# Maximum number of events to keep in history
-#max_events = 100
-
-# 4. LLM Summarizing Condenser
-#type = "llm"
-# Reference to an LLM config to use for summarization
-#llm_config = "condenser"
-# Number of initial events to always keep (typically includes task description)
-#keep_first = 1
-# Maximum size of history before triggering summarization
-#max_size = 100
-
-# 5. Amortized Forgetting Condenser
-#type = "amortized"
-# Number of initial events to always keep (typically includes task description)
-#keep_first = 1
-# Maximum size of history before triggering forgetting
-#max_size = 100
-
-# 6. LLM Attention Condenser
-#type = "llm_attention"
-# Reference to an LLM config to use for attention scoring
-#llm_config = "condenser"
-# Number of initial events to always keep (typically includes task description)
-#keep_first = 1
-# Maximum size of history before triggering attention mechanism
-#max_size = 100
-
-# Example of a custom LLM configuration for condensers that require an LLM
-# If not provided, it falls back to the default LLM
-#[llm.condenser]
-#model = "gpt-4o"
-#temperature = 0.1
-#max_input_tokens = 1024
-
-########################### Kubernetes #######################################
-# Kubernetes configuration when using the Kubernetes runtime
-##############################################################################
-[kubernetes]
-# The Kubernetes namespace to use for OpenHands resources
-#namespace = "default"
-
-# Domain for ingress resources
-#ingress_domain = "localhost"
-
-# Size of the persistent volume claim
-#pvc_storage_size = "2Gi"
-
-# Storage class for persistent volume claims
-#pvc_storage_class = "standard"
-
-# CPU request for runtime pods
-#resource_cpu_request = "1"
-
-# Memory request for runtime pods
-#resource_memory_request = "1Gi"
-
-# Memory limit for runtime pods
-#resource_memory_limit = "2Gi"
-
-# Optional name of image pull secret for private registries
-#image_pull_secret = ""
-
-# Optional name of TLS secret for ingress
-#ingress_tls_secret = ""
-
-# Optional node selector key for pod scheduling
-#node_selector_key = ""
-
-# Optional node selector value for pod scheduling
-#node_selector_val = ""
-
-# Optional YAML string defining pod tolerations
-#tolerations_yaml = ""
-
-# Run the runtime sandbox container in privileged mode for use with docker-in-docker
-#privileged = false
-
-#################################### MCP #####################################
-# Configuration for Model Context Protocol (MCP) servers
-# MCP allows OpenHands to communicate with external tool servers
-##############################################################################
-[mcp]
-# SSE servers - Server-Sent Events transport (legacy)
-#sse_servers = [
-#    # Basic SSE server with just a URL
-#    "http://localhost:8080/mcp/sse",
-#
-#    # SSE server with authentication
-#    {url = "https://api.example.com/mcp/sse", api_key = "your-api-key"}
-#]
-
-# SHTTP servers - Streamable HTTP transport (recommended)
-#shttp_servers = [
-#    # Basic SHTTP server with default 60s timeout
-#    "https://api.example.com/mcp/shttp",
-#
-#    # SHTTP server with custom timeout for long-running tools
-#    {
-#        url = "https://api.example.com/mcp/shttp",
-#        api_key = "your-api-key",
-#        timeout = 180  # 3 minutes for processing-heavy tools (1-3600 seconds)
-#    }
-#]
-
-# Stdio servers - Direct process communication (development only)
-#stdio_servers = [
-#    # Basic stdio server
-#    {name = "filesystem", command = "npx", args = ["@modelcontextprotocol/server-filesystem", "/"]},
-#
-#    # Stdio server with environment variables
-#    {
-#        name = "fetch",
-#        command = "uvx",
-#        args = ["mcp-server-fetch"],
-#        env = {DEBUG = "true"}
-#    }
-#]
-
-#################################### Model Routing ############################
-# Configuration for experimental model routing feature
-# Enables intelligent switching between different LLM models for specific purposes
-##############################################################################
-[model_routing]
-# Router to use for model selection
-# Available options:
-# - "noop_router" (default): No routing, always uses primary LLM
-# - "multimodal_router": A router that switches between primary and secondary models, depending on whether the input is multimodal or not
-#router_name = "noop_router"

containers/README.md

@@ -1,12 +0,0 @@
-# Docker Containers
-
-Each folder here contains a Dockerfile, and a config.sh describing how to build
-the images and where to push them. These images are built and pushed in GitHub Actions
-by the `ghcr.yml` workflow.
-
-## Building Manually
-
-```bash
-docker build -f containers/app/Dockerfile -t openhands .
-docker build -f containers/sandbox/Dockerfile -t sandbox .
-```

containers/app/Dockerfile

@@ -1,95 +0,0 @@
-ARG OPENHANDS_BUILD_VERSION=dev
-FROM node:25.2-trixie-slim AS frontend-builder
-
-WORKDIR /app
-
-COPY frontend/package.json frontend/package-lock.json ./
-RUN npm ci
-
-COPY frontend ./
-RUN npm run build
-
-FROM python:3.13.7-slim-trixie AS base
-FROM base AS backend-builder
-
-WORKDIR /app
-ENV PYTHONPATH='/app'
-
-ENV POETRY_NO_INTERACTION=1 \
-    POETRY_VIRTUALENVS_IN_PROJECT=1 \
-    POETRY_VIRTUALENVS_CREATE=1 \
-    POETRY_CACHE_DIR=/tmp/poetry_cache
-
-RUN apt-get update -y \
-    && apt-get install -y curl make git build-essential jq gettext \
-    && python3 -m pip install poetry --break-system-packages
-
-COPY pyproject.toml poetry.lock ./
-RUN touch README.md
-RUN export POETRY_CACHE_DIR && poetry install --no-root && rm -rf $POETRY_CACHE_DIR
-
-FROM base AS openhands-app
-
-WORKDIR /app
-
-# re-declare for this section
-ARG OPENHANDS_BUILD_VERSION
-
-ENV RUN_AS_OPENHANDS=true
-# A random number--we need this to be different from the user's UID on the host machine
-ENV OPENHANDS_USER_ID=42420
-ENV SANDBOX_LOCAL_RUNTIME_URL=http://host.docker.internal
-ENV USE_HOST_NETWORK=false
-ENV WORKSPACE_BASE=/opt/workspace_base
-ENV OPENHANDS_BUILD_VERSION=$OPENHANDS_BUILD_VERSION
-ENV SANDBOX_USER_ID=0
-ENV FILE_STORE=local
-ENV FILE_STORE_PATH=/.openhands
-ENV INIT_GIT_IN_EMPTY_WORKSPACE=1
-RUN mkdir -p $FILE_STORE_PATH
-RUN mkdir -p $WORKSPACE_BASE
-
-RUN apt-get update -y \
-    && apt-get install -y curl ssh sudo \
-    && rm -rf /var/lib/apt/lists/*
-
-# Default is 1000, but OSX is often 501
-RUN sed -i 's/^UID_MIN.*/UID_MIN 499/' /etc/login.defs
-# Default is 60000, but we've seen up to 200000
-RUN sed -i 's/^UID_MAX.*/UID_MAX 1000000/' /etc/login.defs
-
-RUN groupadd --gid $OPENHANDS_USER_ID openhands
-RUN useradd -l -m -u $OPENHANDS_USER_ID --gid $OPENHANDS_USER_ID -s /bin/bash openhands && \
-    usermod -aG openhands openhands && \
-    usermod -aG sudo openhands && \
-    echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
-RUN chown -R openhands:openhands /app && chmod -R 770 /app
-RUN sudo chown -R openhands:openhands $WORKSPACE_BASE && sudo chmod -R 770 $WORKSPACE_BASE
-USER openhands
-
-ENV VIRTUAL_ENV=/app/.venv \
-    PATH="/app/.venv/bin:$PATH" \
-    PYTHONPATH='/app'
-
-COPY --chown=openhands:openhands --chmod=770 --from=backend-builder ${VIRTUAL_ENV} ${VIRTUAL_ENV}
-
-COPY --chown=openhands:openhands --chmod=770 ./skills ./skills
-COPY --chown=openhands:openhands --chmod=770 ./openhands ./openhands
-COPY --chown=openhands:openhands --chmod=777 ./openhands/runtime/plugins ./openhands/runtime/plugins
-COPY --chown=openhands:openhands pyproject.toml poetry.lock README.md MANIFEST.in LICENSE ./
-
-# This is run as "openhands" user, and will create __pycache__ with openhands:openhands ownership
-RUN python openhands/core/download.py # No-op to download assets
-# Add this line to set group ownership of all files/directories not already in "app" group
-# openhands:openhands -> openhands:openhands
-RUN find /app \! -group openhands -exec chgrp openhands {} +
-
-COPY --chown=openhands:openhands --chmod=770 --from=frontend-builder /app/build ./frontend/build
-COPY --chown=openhands:openhands --chmod=770 ./containers/app/entrypoint.sh /app/entrypoint.sh
-
-USER root
-
-WORKDIR /app
-
-ENTRYPOINT ["/app/entrypoint.sh"]
-CMD ["uvicorn", "openhands.server.listen:app", "--host", "0.0.0.0", "--port", "3000"]

containers/app/config.sh

@@ -1,4 +0,0 @@
-DOCKER_REGISTRY=ghcr.io
-DOCKER_ORG=openhands
-DOCKER_IMAGE=openhands
-DOCKER_BASE_DIR="."

containers/app/entrypoint.sh

@@ -1,73 +0,0 @@
-#!/bin/bash
-set -eo pipefail
-
-echo "Starting OpenHands..."
-if [[ $NO_SETUP == "true" ]]; then
-  echo "Skipping setup, running as $(whoami)"
-  "$@"
-  exit 0
-fi
-
-if [ "$(id -u)" -ne 0 ]; then
-  echo "The OpenHands entrypoint.sh must run as root"
-  exit 1
-fi
-
-if [ -z "$SANDBOX_USER_ID" ]; then
-  echo "SANDBOX_USER_ID is not set"
-  exit 1
-fi
-
-if [ -z "$WORKSPACE_MOUNT_PATH" ]; then
-  # This is set to /opt/workspace in the Dockerfile. But if the user isn't mounting, we want to unset it so that OpenHands doesn't mount at all
-  unset WORKSPACE_BASE
-fi
-
-if [[ "$INSTALL_THIRD_PARTY_RUNTIMES" == "true" ]]; then
-  echo "Downloading and installing third_party_runtimes..."
-  echo "Warning: Third-party runtimes are provided as-is, not actively supported and may be removed in future releases."
-
-  if pip install 'openhands-ai[third_party_runtimes]' -qqq 2> >(tee /dev/stderr); then
-    echo "third_party_runtimes installed successfully."
-  else
-    echo "Failed to install third_party_runtimes." >&2
-    exit 1
-  fi
-fi
-
-if [[ "$SANDBOX_USER_ID" -eq 0 ]]; then
-  echo "Running OpenHands as root"
-  export RUN_AS_OPENHANDS=false
-  "$@"
-else
-  echo "Setting up enduser with id $SANDBOX_USER_ID"
-  if id "enduser" &>/dev/null; then
-    echo "User enduser already exists. Skipping creation."
-  else
-    if ! useradd -l -m -u $SANDBOX_USER_ID -s /bin/bash enduser; then
-      echo "Failed to create user enduser with id $SANDBOX_USER_ID. Moving openhands user."
-      incremented_id=$(($SANDBOX_USER_ID + 1))
-      usermod -u $incremented_id openhands
-      if ! useradd -l -m -u $SANDBOX_USER_ID -s /bin/bash enduser; then
-        echo "Failed to create user enduser with id $SANDBOX_USER_ID for a second time. Exiting."
-        exit 1
-      fi
-    fi
-  fi
-  usermod -aG openhands enduser
-  # get the user group of /var/run/docker.sock and set openhands to that group
-  DOCKER_SOCKET_GID=$(stat -c '%g' /var/run/docker.sock)
-  echo "Docker socket group id: $DOCKER_SOCKET_GID"
-  if getent group $DOCKER_SOCKET_GID; then
-    echo "Group with id $DOCKER_SOCKET_GID already exists"
-  else
-    echo "Creating group with id $DOCKER_SOCKET_GID"
-    groupadd -g $DOCKER_SOCKET_GID docker
-  fi
-
-  mkdir -p /home/enduser/.cache/huggingface/hub/
-
-  usermod -aG $DOCKER_SOCKET_GID enduser
-  echo "Running as enduser"
-  su enduser /bin/bash -c "${*@Q}" # This magically runs any arguments passed to the script as a command
-fi

containers/build.sh

@@ -1,182 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-
-# Initialize variables with default values
-image_name=""
-org_name=""
-push=0
-load=0
-tag_suffix=""
-dry_run=0
-
-# Function to display usage information
-usage() {
-    echo "Usage: $0 -i <image_name> [-o <org_name>] [--push] [--load] [-t <tag_suffix>] [--dry]"
-    echo "  -i: Image name (required)"
-    echo "  -o: Organization name"
-    echo "  --push: Push the image"
-    echo "  --load: Load the image"
-    echo "  -t: Tag suffix"
-    echo "  --dry: Don't build, only create build-args.json"
-    exit 1
-}
-
-# Parse command-line options
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -i) image_name="$2"; shift 2 ;;
-        -o) org_name="$2"; shift 2 ;;
-        --push) push=1; shift ;;
-        --load) load=1; shift ;;
-        -t) tag_suffix="$2"; shift 2 ;;
-        --dry) dry_run=1; shift ;;
-        *) usage ;;
-    esac
-done
-# Check if required arguments are provided
-if [[ -z "$image_name" ]]; then
-    echo "Error: Image name is required."
-    usage
-fi
-
-echo "Building: $image_name"
-tags=()
-
-OPENHANDS_BUILD_VERSION="dev"
-
-cache_tag_base="buildcache"
-cache_tag="$cache_tag_base"
-
-if [[ -n $RELEVANT_SHA ]]; then
-  git_hash=$(git rev-parse --short "$RELEVANT_SHA")
-  tags+=("$git_hash")
-  tags+=("$RELEVANT_SHA")
-fi
-
-if [[ -n $GITHUB_REF_NAME ]]; then
-  # check if ref name is a version number
-  if [[ $GITHUB_REF_NAME =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-    major_version=$(echo "$GITHUB_REF_NAME" | cut -d. -f1)
-    minor_version=$(echo "$GITHUB_REF_NAME" | cut -d. -f1,2)
-    tags+=("$major_version" "$minor_version")
-    tags+=("latest")
-  fi
-  sanitized_ref_name=$(echo "$GITHUB_REF_NAME" | sed 's/[^a-zA-Z0-9.-]\+/-/g')
-  OPENHANDS_BUILD_VERSION=$sanitized_ref_name
-  sanitized_ref_name=$(echo "$sanitized_ref_name" | tr '[:upper:]' '[:lower:]') # lower case is required in tagging
-  tags+=("$sanitized_ref_name")
-  cache_tag+="-${sanitized_ref_name}"
-fi
-
-if [[ -n $tag_suffix ]]; then
-  cache_tag+="-${tag_suffix}"
-  for i in "${!tags[@]}"; do
-    tags[$i]="${tags[$i]}-$tag_suffix"
-  done
-fi
-
-echo "Tags: ${tags[@]}"
-
-if [[ "$image_name" == "openhands" ]]; then
-  dir="./containers/app"
-elif [[ "$image_name" == "runtime" ]]; then
-  dir="./containers/runtime"
-else
-  dir="./containers/$image_name"
-fi
-
-if [[ (! -f "$dir/Dockerfile") && "$image_name" != "runtime" ]]; then
-  # Allow runtime to be built without a Dockerfile
-  echo "No Dockerfile found"
-  exit 1
-fi
-if [[ ! -f "$dir/config.sh" ]]; then
-  echo "No config.sh found for Dockerfile"
-  exit 1
-fi
-
-source "$dir/config.sh"
-
-if [[ -n "$org_name" ]]; then
-  DOCKER_ORG="$org_name"
-fi
-
-# If $DOCKER_IMAGE_SOURCE_TAG is set, add it to the tags
-if [[ -n "$DOCKER_IMAGE_SOURCE_TAG" ]]; then
-  tags+=("$DOCKER_IMAGE_SOURCE_TAG")
-fi
-# If $DOCKER_IMAGE_TAG is set, add it to the tags
-if [[ -n "$DOCKER_IMAGE_TAG" ]]; then
-  tags+=("$DOCKER_IMAGE_TAG")
-fi
-
-DOCKER_REPOSITORY="$DOCKER_REGISTRY/$DOCKER_ORG/$DOCKER_IMAGE"
-DOCKER_REPOSITORY=${DOCKER_REPOSITORY,,} # lowercase
-echo "Repo: $DOCKER_REPOSITORY"
-echo "Base dir: $DOCKER_BASE_DIR"
-
-args=""
-full_tags=()
-for tag in "${tags[@]}"; do
-  args+=" -t $DOCKER_REPOSITORY:$tag"
-  full_tags+=("$DOCKER_REPOSITORY:$tag")
-done
-
-
-if [[ $push -eq 1 ]]; then
-  args+=" --push"
-  args+=" --cache-to=type=registry,ref=$DOCKER_REPOSITORY:$cache_tag,mode=max"
-fi
-
-if [[ $load -eq 1 ]]; then
-  args+=" --load"
-fi
-
-echo "Args: $args"
-
-# Modify the platform selection based on --load flag
-if [[ $load -eq 1 ]]; then
-  # When loading, build only for the current platform
-  platform=$(docker version -f '{{.Server.Os}}/{{.Server.Arch}}')
-else
-  # For push or without load, build for multiple platforms
-  platform="linux/amd64,linux/arm64"
-fi
-if [[ $dry_run -eq 1 ]]; then
-  echo "Dry Run is enabled. Writing build config to docker-build-dry.json"
-  jq -n \
-    --argjson tags "$(printf '%s\n' "${full_tags[@]}" | jq -R . | jq -s .)" \
-    --arg platform "$platform" \
-    --arg openhands_build_version "$OPENHANDS_BUILD_VERSION" \
-    --arg dockerfile "$dir/Dockerfile" \
-    '{
-      tags: $tags,
-      platform: $platform,
-      build_args: [
-        "OPENHANDS_BUILD_VERSION=" + $openhands_build_version
-      ],
-      dockerfile: $dockerfile
-    }' > docker-build-dry.json
-
-    exit 0
-fi
-
-
-
-echo "Building for platform(s): $platform"
-
-docker buildx build \
-  $args \
-  --build-arg OPENHANDS_BUILD_VERSION="$OPENHANDS_BUILD_VERSION" \
-  --cache-from=type=registry,ref=$DOCKER_REPOSITORY:$cache_tag \
-  --cache-from=type=registry,ref=$DOCKER_REPOSITORY:$cache_tag_base-main \
-  --platform $platform \
-  --provenance=false \
-  -f "$dir/Dockerfile" \
-  "$DOCKER_BASE_DIR"
-
-# If load was requested, print the loaded images
-if [[ $load -eq 1 ]]; then
-  echo "Local images built:"
-  docker images "$DOCKER_REPOSITORY" --format "{{.Repository}}:{{.Tag}}"
-fi

containers/dev/Dockerfile

@@ -1,127 +0,0 @@
-# syntax=docker/dockerfile:1
-
-###
-FROM ubuntu:22.04 AS dind
-
-# https://docs.docker.com/engine/install/ubuntu/
-RUN apt-get update && apt-get install -y \
-	ca-certificates \
-	curl \
-	&& install -m 0755 -d /etc/apt/keyrings \
-	&& curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc \
-	&& chmod a+r /etc/apt/keyrings/docker.asc \
-	&& echo \
-		"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
-		$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
-
-RUN apt-get update && apt-get install -y \
-	docker-ce \
-	docker-ce-cli \
-	containerd.io \
-	docker-buildx-plugin \
-	docker-compose-plugin \
-	&& rm -rf /var/lib/apt/lists/* \
-	&& apt-get clean \
-	&& apt-get autoremove -y
-
-###
-FROM dind AS openhands
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-#
-RUN apt-get update && apt-get install -y \
-	bash \
-    build-essential \
-    curl \
-	git \
-	git-lfs \
-	software-properties-common \
-	make \
-    netcat \
-    sudo \
-	wget \
-	&& rm -rf /var/lib/apt/lists/* \
-	&& apt-get clean \
-	&& apt-get autoremove -y
-
-# https://github.com/cli/cli/blob/trunk/docs/install_linux.md
-RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \
-	&& chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \
-	&& echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
-	&& apt-get update && apt-get -y install \
-    gh \
-  && rm -rf /var/lib/apt/lists/* \
-  && apt-get clean \
-  && apt-get autoremove -y
-
-# Python 3.12
-RUN add-apt-repository ppa:deadsnakes/ppa \
-    && apt-get update \
-    && apt-get install -y python3.12 python3.12-venv python3.12-dev python3-pip \
-    && ln -s /usr/bin/python3.12 /usr/bin/python
-
-# NodeJS >= 22.x
-RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
-    && apt-get install -y nodejs
-
-# Poetry >= 1.8
-RUN curl -fsSL https://install.python-poetry.org | python3.12 - \
-    && ln -s ~/.local/bin/poetry /usr/local/bin/poetry
-
-#
-RUN <<EOF
-#!/bin/bash
-printf "#!/bin/bash
-set +x
-uname -a
-docker --version
-gh --version | head -n 1
-git --version
-#
-python --version
-echo node `node --version`
-echo npm `npm --version`
-poetry --version
-netcat -h 2>&1 | head -n 1
-" > /version.sh
-chmod a+x /version.sh
-EOF
-
-###
-FROM openhands AS dev
-
-RUN apt-get update && apt-get install -y \
-	dnsutils \
-	file \
-	iproute2 \
-	jq \
-	lsof \
-	ripgrep \
-	silversearcher-ag \
-	vim \
-	&& rm -rf /var/lib/apt/lists/* \
-	&& apt-get clean \
-	&& apt-get autoremove -y
-
-# mark /app as safe git directory to avoid pre-commit errors
-RUN git config --system --add safe.directory /app
-
-WORKDIR /app
-
-# cache build dependencies
-RUN \
-  --mount=type=bind,source=./,target=/app/,rw \
-  <<EOF
-#!/bin/bash
-make -s clean
-make -s check-dependencies
-make -s install-python-dependencies
-
-# NOTE
-# node_modules are .dockerignore-d therefore not mountable
-# make -s install-frontend-dependencies
-EOF
-
-#
-CMD ["bash"]

containers/dev/README.md

@@ -1,57 +0,0 @@
-# Develop in Docker
-
-> [!WARNING]
-> This way of running OpenHands is not officially supported. It is maintained by the community and may not work.
-
-Install [Docker](https://docs.docker.com/engine/install/) on your host machine and run:
-
-```bash
-make docker-dev
-# same as:
-cd ./containers/dev
-./dev.sh
-```
-
-It could take some time if you are running for the first time as Docker will pull all the  tools required for building OpenHands. The next time you run again, it should be instant.
-
-## Build and run
-
-If everything goes well, you should be inside a container after Docker finishes building the `openhands:dev` image similar to the following:
-
-```bash
-Build and run in Docker ...
-root@93fc0005fcd2:/app#
-```
-
-You may now proceed with the normal [build and run](../../Development.md) workflow as if you were on the host.
-
-## Make changes
-
-The source code on the host is mounted as `/app` inside docker. You may edit the files as usual either inside the Docker container or on your host with your favorite IDE/editors.
-
-The following are also mapped as readonly from your host:
-
-```yaml
-# host credentials
-- $HOME/.git-credentials:/root/.git-credentials:ro
-- $HOME/.gitconfig:/root/.gitconfig:ro
-- $HOME/.npmrc:/root/.npmrc:ro
-```
-
-## VSCode
-
-Alternatively, if you use VSCode, you could also [attach to the running container](https://code.visualstudio.com/docs/devcontainers/attach-container).
-
-See details for [developing in docker](https://code.visualstudio.com/docs/devcontainers/containers) or simply ask `OpenHands` ;-)
-
-## Rebuild dev image
-
-You could optionally pass additional options to the build script.
-
-```bash
-make docker-dev OPTIONS="--build"
-# or
-./containers/dev/dev.sh --build
-```
-
-See [docker compose run](https://docs.docker.com/reference/cli/docker/compose/run/) for more options.

containers/dev/compose.yml

@@ -1,40 +0,0 @@
-#
-services:
-  dev:
-    privileged: true
-    build:
-      context: ${OPENHANDS_WORKSPACE:-../../}
-      dockerfile: ./containers/dev/Dockerfile
-    image: openhands:dev
-    container_name: openhands-dev
-    environment:
-      - BACKEND_HOST=${BACKEND_HOST:-"0.0.0.0"}
-      - SANDBOX_API_HOSTNAME=host.docker.internal
-      - DOCKER_HOST_ADDR=host.docker.internal
-      #
-      - AGENT_SERVER_IMAGE_REPOSITORY=${AGENT_SERVER_IMAGE_REPOSITORY:-ghcr.io/openhands/runtime}
-      - AGENT_SERVER_IMAGE_TAG=${AGENT_SERVER_IMAGE_TAG:-1.2-nikolaik}
-      - SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234}
-      - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
-    ports:
-      - "3000:3000"
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-      - ${WORKSPACE_BASE:-$PWD/workspace}:/opt/workspace_base
-      # source code
-      - ${OPENHANDS_WORKSPACE:-../../}:/app
-      # host credentials
-      - $HOME/.git-credentials:/root/.git-credentials:ro
-      - $HOME/.gitconfig:/root/.gitconfig:ro
-      - $HOME/.npmrc:/root/.npmrc:ro
-      # cache
-      - cache-data:/root/.cache
-    pull_policy: never
-    stdin_open: true
-    tty: true
-
-##
-volumes:
-  cache-data:

containers/dev/dev.sh

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-set -o pipefail
-
-function get_docker() {
-    echo "Docker is required to build and run OpenHands."
-    echo "https://docs.docker.com/get-started/get-docker/"
-    exit 1
-}
-
-function check_tools() {
-	command -v docker &>/dev/null || get_docker
-}
-
-function exit_if_indocker() {
-    if [ -f /.dockerenv ]; then
-        echo "Running inside a Docker container. Exiting..."
-        exit 1
-    fi
-}
-
-#
-exit_if_indocker
-
-check_tools
-
-##
-OPENHANDS_WORKSPACE=$(git rev-parse --show-toplevel)
-
-cd "$OPENHANDS_WORKSPACE/containers/dev/" || exit 1
-
-##
-export BACKEND_HOST="0.0.0.0"
-#
-export SANDBOX_USER_ID=$(id -u)
-export WORKSPACE_BASE=${WORKSPACE_BASE:-$OPENHANDS_WORKSPACE/workspace}
-
-docker compose run --rm --service-ports "$@" dev
-
-##

containers/runtime/README.md

@@ -1,12 +0,0 @@
-# Dynamically constructed Dockerfile
-
-This folder builds a runtime image (sandbox), which will use a dynamically generated `Dockerfile`
-that depends on the `base_image` **AND** a [Python source distribution](https://docs.python.org/3.10/distutils/sourcedist.html) that is based on the current commit of `openhands`.
-
-The following command will generate a `Dockerfile` file for `nikolaik/python-nodejs:python3.12-nodejs22` (the default base image), an updated `config.sh` and the runtime source distribution files/folders into `containers/runtime`:
-
-```bash
-poetry run python3 -m openhands.runtime.utils.runtime_build \
-    --base_image nikolaik/python-nodejs:python3.12-nodejs22 \
-    --build_folder containers/runtime
-```

containers/runtime/config.sh

@@ -1,7 +0,0 @@
-DOCKER_REGISTRY=ghcr.io
-DOCKER_ORG=openhands
-DOCKER_BASE_DIR="./containers/runtime"
-DOCKER_IMAGE=runtime
-# These variables will be appended by the runtime_build.py script
-# DOCKER_IMAGE_TAG=
-# DOCKER_IMAGE_SOURCE_TAG=

dev_config/python/.pre-commit-config.yaml

@@ -1,65 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
-    hooks:
-      - id: trailing-whitespace
-        exclude: ^(docs/|modules/|python/|openhands-ui/|third_party/|enterprise/)
-      - id: end-of-file-fixer
-        exclude: ^(docs/|modules/|python/|openhands-ui/|third_party/|enterprise/)
-      - id: check-yaml
-        args: ["--allow-multiple-documents"]
-      - id: debug-statements
-
-
-  - repo: local
-    hooks:
-      - id: warn-appmode-oss
-        name: "Warn on AppMode.OSS in backend (use AppMode.OPENHANDS)"
-        language: system
-        entry: bash -lc 'if rg -n "\\bAppMode\\.OSS\\b" openhands tests/unit; then echo "Found AppMode.OSS usage. Prefer AppMode.OPENHANDS."; exit 1; fi'
-        pass_filenames: false
-
-  - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: v2.5.1
-    hooks:
-      - id: pyproject-fmt
-  - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.24.1
-    hooks:
-      - id: validate-pyproject
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    # Ruff version.
-    rev: v0.11.8
-    hooks:
-      # Run the linter.
-      - id: ruff
-        entry: ruff check --config dev_config/python/ruff.toml
-        types_or: [python, pyi, jupyter]
-        args: [--fix, --unsafe-fixes]
-        exclude: ^(third_party/|enterprise/)
-      # Run the formatter.
-      - id: ruff-format
-        entry: ruff format --config dev_config/python/ruff.toml
-        types_or: [python, pyi, jupyter]
-        exclude: ^(third_party/|enterprise/)
-
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.15.0
-    hooks:
-      - id: mypy
-        additional_dependencies:
-          [
-            types-requests,
-            types-setuptools,
-            types-pyyaml,
-            types-toml,
-            types-docker,
-            types-Markdown,
-            pydantic,
-            lxml,
-          ]
-        # To see gaps add `--html-report mypy-report/`
-        entry: mypy --config-file dev_config/python/mypy.ini openhands/
-        always_run: true
-        pass_filenames: false

dev_config/python/mypy.ini

@@ -1,16 +0,0 @@
-[mypy]
-warn_unused_configs = True
-ignore_missing_imports = True
-check_untyped_defs = True
-explicit_package_bases = True
-warn_unreachable = True
-warn_redundant_casts = True
-no_implicit_optional = True
-strict_optional = True
-disable_error_code = type-abstract
-
-# Exclude third-party runtime directory from type checking
-exclude = (third_party/|enterprise/)
-
-[mypy-openhands.memory.condenser.impl.*]
-disable_error_code = override

dev_config/python/ruff.toml

@@ -1,42 +0,0 @@
-# Exclude third-party runtime directory from linting
-exclude = ["third_party/", "enterprise/"]
-
-[lint]
-select = [
-    "E",
-    "W",
-    "F",
-    "I",
-    "Q",
-    "B",
-    "ASYNC",
-    "UP006",  # Use `list` instead of `List` for annotations
-    "UP007",  # Use `X | Y` instead of `Union[X, Y]`
-    "UP008",  # Use `X | None` instead of `Optional[X]`
-]
-
-ignore = [
-    "E501",
-    "B003",
-    "B007",
-    "B009",
-    "B010",
-    "B904",
-    "B018",
-    # Temporarily ignore ASYNC rules until they can be properly fixed in a separate PR
-    "ASYNC110",
-    "ASYNC220",
-    "ASYNC221",
-    "ASYNC230",
-    "ASYNC251",
-]
-
-[lint.flake8-quotes]
-docstring-quotes = "double"
-inline-quotes = "single"
-
-[format]
-quote-style = "single"
-
-[lint.flake8-bugbear]
-extend-immutable-calls = ["Depends", "fastapi.Depends", "fastapi.params.Depends"]

docker-compose.yml

@@ -1,24 +0,0 @@
-
-services:
-  openhands:
-    build:
-      context: ./
-      dockerfile: ./containers/app/Dockerfile
-    image: openhands:latest
-    container_name: openhands-app-${DATE:-}
-    environment:
-      - AGENT_SERVER_IMAGE_REPOSITORY=${AGENT_SERVER_IMAGE_REPOSITORY:-ghcr.io/openhands/agent-server}
-      - AGENT_SERVER_IMAGE_TAG=${AGENT_SERVER_IMAGE_TAG:-31536c8-python}
-      #- SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234} # enable this only if you want a specific non-root sandbox user but you will have to manually adjust permissions of ~/.openhands for this user
-      - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
-    ports:
-      - "3000:3000"
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-      - ~/.openhands:/.openhands
-      - ${WORKSPACE_BASE:-$PWD/workspace}:/opt/workspace_base
-    pull_policy: build
-    stdin_open: true
-    tty: true

enterprise/Dockerfile

@@ -1,39 +0,0 @@
-ARG OPENHANDS_VERSION=latest
-ARG BASE="ghcr.io/openhands/openhands"
-FROM ${BASE}:${OPENHANDS_VERSION}
-
-# Datadog labels
-LABEL com.datadoghq.tags.service="deploy"
-LABEL com.datadoghq.tags.env="${DD_ENV}"
-
-# Install Node.js v20+ and npm (which includes npx)
-# Apply security updates to fix CVEs
-RUN apt-get update && \
-    apt-get install -y curl && \
-    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
-    apt-get install -y nodejs && \
-    apt-get install -y jq gettext && \
-    # Apply security updates for packages with available fixes
-    apt-get upgrade -y \
-        libc-bin \
-        libc6 \
-        libgnutls30 \
-        libsqlite3-0 \
-        perl-base && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-# Install Python packages with security fixes
-RUN /app/.venv/bin/pip install alembic psycopg2-binary cloud-sql-python-connector pg8000 gspread stripe python-keycloak asyncpg sqlalchemy[asyncio] resend tenacity slack-sdk ddtrace "posthog>=6.0.0" "limits==5.2.0" coredis prometheus-client shap scikit-learn pandas numpy google-cloud-recaptcha-enterprise && \
-    # Update packages with known CVE fixes
-    /app/.venv/bin/pip install --upgrade \
-        "mcp>=1.10.0" \
-        "pillow>=11.3.0"
-
-WORKDIR /app
-COPY --chown=openhands:openhands --chmod=770 enterprise .
-
-USER openhands
-
-# Command will be overridden by Kubernetes deployment template
-CMD ["uvicorn", "saas_server:app", "--host", "0.0.0.0", "--port", "3000"]

enterprise/LICENSE

@@ -1,89 +0,0 @@
-# PolyForm Free Trial License 1.0.0
-
-## Acceptance
-
-In order to get any license under these terms, you must agree
-to them as both strict obligations and conditions to all
-your licenses.
-
-## Copyright License
-
-The licensor grants you a copyright license for the software
-to do everything you might do with the software that would
-otherwise infringe the licensor's copyright in it for any
-permitted purpose.  However, you may only make changes or
-new works based on the software according to [Changes and New
-Works License](#changes-and-new-works-license), and you may
-not distribute copies of the software.
-
-## Changes and New Works License
-
-The licensor grants you an additional copyright license to
-make changes and new works based on the software for any
-permitted purpose.
-
-## Patent License
-
-The licensor grants you a patent license for the software that
-covers patent claims the licensor can license, or becomes able
-to license, that you would infringe by using the software.
-
-## Fair Use
-
-You may have "fair use" rights for the software under the
-law. These terms do not limit them.
-
-## Free Trial
-
-Use of the software for more than 30 days per calendar year is not allowed without a commercial license.
-
-## No Other Rights
-
-These terms do not allow you to sublicense or transfer any of
-your licenses to anyone else, or prevent the licensor from
-granting licenses to anyone else.  These terms do not imply
-any other licenses.
-
-## Patent Defense
-
-If you make any written claim that the software infringes or
-contributes to infringement of any patent, your patent license
-for the software granted under these terms ends immediately. If
-your company makes such a claim, your patent license ends
-immediately for work on behalf of your company.
-
-## Violations
-
-If you violate any of these terms, or do anything with the
-software not covered by your licenses, all your licenses
-end immediately.
-
-## No Liability
-
-***As far as the law allows, the software comes as is, without
-any warranty or condition, and the licensor will not be liable
-to you for any damages arising out of these terms or the use
-or nature of the software, under any kind of legal claim.***
-
-## Definitions
-
-The **licensor** is the individual or entity offering these
-terms, and the **software** is the software the licensor makes
-available under these terms.
-
-**You** refers to the individual or entity agreeing to these
-terms.
-
-**Your company** is any legal entity, sole proprietorship,
-or other kind of organization that you work for, plus all
-organizations that have control over, are under the control of,
-or are under common control with that organization.  **Control**
-means ownership of substantially all the assets of an entity,
-or the power to direct its management and policies by vote,
-contract, or otherwise.  Control can be direct or indirect.
-
-**Your licenses** are all the licenses granted to you for the
-software under these terms.
-
-**Use** means anything you do with the software requiring one
-of your licenses.

enterprise/Makefile

@@ -1,42 +0,0 @@
-BACKEND_HOST ?= "127.0.0.1"
-BACKEND_PORT = 3000
-BACKEND_HOST_PORT = "$(BACKEND_HOST):$(BACKEND_PORT)"
-FRONTEND_PORT = 3001
-OPENHANDS_PATH ?= ".."
-OPENHANDS := $(OPENHANDS_PATH)
-OPENHANDS_FRONTEND_PATH = $(OPENHANDS)/frontend/build
-
-# ANSI color codes
-GREEN=$(shell tput -Txterm setaf 2)
-YELLOW=$(shell tput -Txterm setaf 3)
-RED=$(shell tput -Txterm setaf 1)
-BLUE=$(shell tput -Txterm setaf 6)
-RESET=$(shell tput -Txterm sgr0)
-
-build:
-	@poetry install
-	@cd $(OPENHANDS) && $(MAKE) build
-
-
-_run_setup:
-	@echo "$(YELLOW)Starting backend server...$(RESET)"
-	@cd app && FRONTEND_DIRECTORY=$(OPENHANDS_FRONTEND_PATH) poetry run uvicorn saas_server:app --host $(BACKEND_HOST) --port $(BACKEND_PORT) &
-	@echo "$(YELLOW)Waiting for the backend to start...$(RESET)"
-	@until nc -z localhost $(BACKEND_PORT); do sleep 0.1; done
-	@echo "$(GREEN)Backend started successfully.$(RESET)"
-
-run:
-	@echo "$(YELLOW)Running the app...$(RESET)"
-	@$(MAKE) -s _run_setup
-	@cd $(OPENHANDS) && $(MAKE) -s start-frontend
-	@echo "$(GREEN)Application started successfully.$(RESET)"
-
-# Start backend
-start-backend:
-	@echo "$(YELLOW)Starting backend...$(RESET)"
-	@echo "$(OPENHANDS_FRONTEND_PATH)"
-	@cd app && FRONTEND_DIRECTORY=$(OPENHANDS_FRONTEND_PATH) poetry run uvicorn saas_server:app --host $(BACKEND_HOST) --port $(BACKEND_PORT) --reload-dir $(OPENHANDS_PATH) --reload --reload-dir ./ --reload-exclude "./workspace"
-
-
-lint:
-	@poetry run pre-commit run --all-files --show-diff-on-failure --config ./dev_config/python/.pre-commit-config.yaml

enterprise/README.md

@@ -1,56 +0,0 @@
-# OpenHands Enterprise Server
-> [!WARNING]
-> This software is licensed under the [Polyform Free Trial License](./LICENSE). This is **NOT** an open source license. Usage is limited to 30 days per calendar year without a commercial license. If you would like to use it beyond 30 days, please [contact us](https://www.openhands.dev/contact).
-
-> [!WARNING]
-> This is a work in progress and may contain bugs, incomplete features, or breaking changes.
-
-This directory contains the enterprise server used by [OpenHands Cloud](https://github.com/All-Hands-AI/OpenHands-Cloud/). The official, public version of OpenHands Cloud is available at
-[app.all-hands.dev](https://app.all-hands.dev).
-
-You may also want to check out the MIT-licensed [OpenHands](https://github.com/OpenHands/OpenHands)
-
-## Extension of OpenHands
-
-The code in `/enterprise` builds on top of OpenHands (MIT-licensed), extending its functionality. The enterprise code is entangled with OpenHands in two ways:
-
-- Enterprise stacks on top of OpenHands. For example, the middleware in enterprise is stacked right on top of the middlewares in OpenHands. In `SAAS`, the middleware from BOTH repos will be present and running (which can sometimes cause conflicts)
-
-- Enterprise overrides the implementation in OpenHands (only one is present at a time). For example, the server config SaasServerConfig overrides [`ServerConfig`](https://github.com/OpenHands/OpenHands/blob/main/openhands/server/config/server_config.py#L8) in OpenHands. This is done through dynamic imports ([see here](https://github.com/OpenHands/OpenHands/blob/main/openhands/server/config/server_config.py#L37-#L45))
-
-Key areas that change on `SAAS` are
-
-- Authentication
-- User settings
-- etc
-
-### Authentication
-
-| Aspect                    | OpenHands                                              | Enterprise                                                                                                                                 |
-| ------------------------- | ------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
-| **Authentication Method** | User adds a personal access token (PAT) through the UI | User performs OAuth through the UI. The GitHub app provides a short-lived access token and refresh token                            |
-| **Token Storage**         | PAT is stored in **Settings**                          | Token is stored in **GithubTokenManager** (a file store in our backend)                                                             |
-| **Authenticated status**  | We simply check if token exists in `Settings`          | We issue a signed cookie with `github_user_id` during OAuth, so subsequent requests with the cookie can be considered authenticated |
-
-Note that in the future, authentication will happen via keycloak. All modifications for authentication will happen in enterprise.
-
-### GitHub Service
-
-The github service is responsible for interacting with Github APIs. As a consequence, it uses the user's token and refreshes it if need be
-
-| Aspect                    | OpenHands                               | Enterprise                                            |
-| ------------------------- | -------------------------------------- | ---------------------------------------------- |
-| **Class used**            | `GitHubService`                        | `SaaSGitHubService`                            |
-| **Token used**            | User's PAT fetched from `Settings`     | User's token fetched from `GitHubTokenManager` |
-| **Refresh functionality** | **N/A**; user provides PAT for the app | Uses the `GitHubTokenManager` to refresh       |
-
-NOTE: in the future we will simply replace the `GithubTokenManager` with keycloak. The `SaaSGithubService` should interact with keycloack instead.
-
-# Areas that are BRITTLE!
-
-## User ID vs User Token
-
-- In OpenHands, the entire app revolves around the GitHub token the user sets. `openhands/server` uses `request.state.github_token` for the entire app
-- On Enterprise, the entire APP resolves around the Github User ID. This is because the cookie sets it, so `openhands/server` AND `enterprise/server` depend on it and completly ignore `request.state.github_token` (token is fetched from `GithubTokenManager` instead)
-
-Note that introducing GitHub User ID in OpenHands, for instance, will cause large breakages.

enterprise/__init__.py

@@ -1 +0,0 @@
-# App package for OpenHands

enterprise/alembic.ini

@@ -1,79 +0,0 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts
-script_location = migrations
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.
-prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python>=3.9 or backports.zoneinfo library.
-# timezone =
-
-# max length of characters to apply to the "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
-sqlalchemy.url = driver://user:pass@localhost/dbname
-
-[post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# Logging configuration
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = DEBUG
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = DEBUG
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = DEBUG
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S

enterprise/dev_config/python/.pre-commit-config.yaml

@@ -1,57 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
-    hooks:
-      - id: trailing-whitespace
-        exclude: docs/modules/python
-        files: ^enterprise/
-      - id: end-of-file-fixer
-        exclude: docs/modules/python
-        files: ^enterprise/
-      - id: check-yaml
-        files: ^enterprise/
-      - id: debug-statements
-        files: ^enterprise/
-  - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.16
-    hooks:
-      - id: validate-pyproject
-        types: [toml]
-        files: ^enterprise/pyproject\.toml$
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    # Ruff version.
-    rev: v0.4.1
-    hooks:
-      # Run the linter.
-      - id: ruff
-        entry: ruff check --config enterprise/dev_config/python/ruff.toml
-        types_or: [python, pyi, jupyter]
-        args: [--fix]
-        files: ^enterprise/
-      # Run the formatter.
-      - id: ruff-format
-        entry: ruff format --config enterprise/dev_config/python/ruff.toml
-        types_or: [python, pyi, jupyter]
-        files: ^enterprise/
-
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.9.0
-    hooks:
-      - id: mypy
-        additional_dependencies:
-          - types-requests
-          - types-setuptools
-          - types-pyyaml
-          - types-toml
-          - types-redis
-          - lxml
-          # OpenHands package in repo root
-          - ./
-          - stripe==11.5.0
-          - pygithub==2.6.1
-        # To see gaps add `--html-report mypy-report/`
-        entry: mypy --config-file enterprise/dev_config/python/mypy.ini enterprise/
-        always_run: true
-        pass_filenames: false
-        files: ^enterprise/

enterprise/dev_config/python/mypy.ini

@@ -1,17 +0,0 @@
-[mypy]
-warn_unused_configs = True
-ignore_missing_imports = True
-check_untyped_defs = True
-explicit_package_bases = True
-warn_unreachable = True
-warn_redundant_casts = True
-no_implicit_optional = True
-strict_optional = True
-disable_error_code = type-abstract
-exclude = (^enterprise/migrations/.*)
-
-[mypy-enterprise.tests.unit.test_auth_routes.*]
-disable_error_code = union-attr
-
-[mypy-enterprise.sync.install_gitlab_webhooks.*]
-disable_error_code = redundant-cast

enterprise/dev_config/python/ruff.toml

@@ -1,31 +0,0 @@
-[lint]
-select = [
-    "E",
-    "W",
-    "F",
-    "I",
-    "Q",
-    "B",
-]
-
-ignore = [
-    "E501",
-    "B003",
-    "B007",
-    "B008",  # Allow function calls in argument defaults (FastAPI Query pattern)
-    "B009",
-    "B010",
-    "B904",
-    "B018",
-]
-
-exclude = [
-    "app/migrations/*"
-]
-
-[lint.flake8-quotes]
-docstring-quotes = "double"
-inline-quotes = "single"
-
-[format]
-quote-style = "single"

enterprise/doc/design-doc/openhands-enterprise-telemetry-design.md

@@ -1,856 +0,0 @@
-# OpenHands Enterprise Usage Telemetry Service
-
-## Table of Contents
-
-1. [Introduction](#1-introduction)
-   - 1.1 [Problem Statement](#11-problem-statement)
-   - 1.2 [Proposed Solution](#12-proposed-solution)
-2. [User Interface](#2-user-interface)
-   - 2.1 [License Warning Banner](#21-license-warning-banner)
-   - 2.2 [Administrator Experience](#22-administrator-experience)
-3. [Other Context](#3-other-context)
-   - 3.1 [Replicated Platform Integration](#31-replicated-platform-integration)
-   - 3.2 [Administrator Email Detection Strategy](#32-administrator-email-detection-strategy)
-   - 3.3 [Metrics Collection Framework](#33-metrics-collection-framework)
-4. [Technical Design](#4-technical-design)
-   - 4.1 [Database Schema](#41-database-schema)
-     - 4.1.1 [Telemetry Metrics Table](#411-telemetry-metrics-table)
-     - 4.1.2 [Telemetry Identity Table](#412-telemetry-identity-table)
-   - 4.2 [Metrics Collection Framework](#42-metrics-collection-framework)
-     - 4.2.1 [Base Collector Interface](#421-base-collector-interface)
-     - 4.2.2 [Collector Registry](#422-collector-registry)
-     - 4.2.3 [Example Collector Implementation](#423-example-collector-implementation)
-   - 4.3 [Collection and Upload System](#43-collection-and-upload-system)
-     - 4.3.1 [Metrics Collection Processor](#431-metrics-collection-processor)
-     - 4.3.2 [Replicated Upload Processor](#432-replicated-upload-processor)
-   - 4.4 [License Warning System](#44-license-warning-system)
-     - 4.4.1 [License Status Endpoint](#441-license-status-endpoint)
-     - 4.4.2 [UI Integration](#442-ui-integration)
-   - 4.5 [Cronjob Configuration](#45-cronjob-configuration)
-     - 4.5.1 [Collection Cronjob](#451-collection-cronjob)
-     - 4.5.2 [Upload Cronjob](#452-upload-cronjob)
-5. [Implementation Plan](#5-implementation-plan)
-   - 5.1 [Database Schema and Models (M1)](#51-database-schema-and-models-m1)
-     - 5.1.1 [OpenHands - Database Migration](#511-openhands---database-migration)
-     - 5.1.2 [OpenHands - Model Tests](#512-openhands---model-tests)
-   - 5.2 [Metrics Collection Framework (M2)](#52-metrics-collection-framework-m2)
-     - 5.2.1 [OpenHands - Core Collection Framework](#521-openhands---core-collection-framework)
-     - 5.2.2 [OpenHands - Example Collectors](#522-openhands---example-collectors)
-     - 5.2.3 [OpenHands - Framework Tests](#523-openhands---framework-tests)
-   - 5.3 [Collection and Upload Processors (M3)](#53-collection-and-upload-processors-m3)
-     - 5.3.1 [OpenHands - Collection Processor](#531-openhands---collection-processor)
-     - 5.3.2 [OpenHands - Upload Processor](#532-openhands---upload-processor)
-     - 5.3.3 [OpenHands - Integration Tests](#533-openhands---integration-tests)
-   - 5.4 [License Warning API (M4)](#54-license-warning-api-m4)
-     - 5.4.1 [OpenHands - License Status API](#541-openhands---license-status-api)
-     - 5.4.2 [OpenHands - API Integration](#542-openhands---api-integration)
-   - 5.5 [UI Warning Banner (M5)](#55-ui-warning-banner-m5)
-     - 5.5.1 [OpenHands - UI Warning Banner](#551-openhands---ui-warning-banner)
-     - 5.5.2 [OpenHands - UI Integration](#552-openhands---ui-integration)
-   - 5.6 [Helm Chart Deployment Configuration (M6)](#56-helm-chart-deployment-configuration-m6)
-     - 5.6.1 [OpenHands-Cloud - Cronjob Manifests](#561-openhands-cloud---cronjob-manifests)
-     - 5.6.2 [OpenHands-Cloud - Configuration Management](#562-openhands-cloud---configuration-management)
-   - 5.7 [Documentation and Enhanced Collectors (M7)](#57-documentation-and-enhanced-collectors-m7)
-     - 5.7.1 [OpenHands - Advanced Collectors](#571-openhands---advanced-collectors)
-     - 5.7.2 [OpenHands - Monitoring and Testing](#572-openhands---monitoring-and-testing)
-     - 5.7.3 [OpenHands - Technical Documentation](#573-openhands---technical-documentation)
-
-## 1. Introduction
-
-### 1.1 Problem Statement
-
-OpenHands Enterprise (OHE) helm charts are publicly available but not open source, creating a visibility gap for the sales team. Unknown users can install and use OHE without the vendor's knowledge, preventing proper customer engagement and sales pipeline management. Without usage telemetry, the vendor cannot identify potential customers, track installation health, or proactively support users who may need assistance.
-
-### 1.2 Proposed Solution
-
-We propose implementing a comprehensive telemetry service that leverages the Replicated metrics platform and Python SDK to track OHE installations and usage. The solution provides automatic customer discovery, instance monitoring, and usage metrics collection while maintaining a clear license compliance pathway.
-
-The system consists of three main components: (1) a pluggable metrics collection framework that allows developers to easily define and register custom metrics collectors, (2) automated cronjobs that periodically collect metrics and upload them to Replicated's vendor portal, and (3) a license compliance warning system that displays UI notifications when telemetry uploads fail, indicating potential license expiration.
-
-The design ensures that telemetry cannot be easily disabled without breaking core OHE functionality by tying the warning system to environment variables that are essential for OHE operation. This approach balances user transparency with business requirements for customer visibility.
-
-## 2. User Interface
-
-### 2.1 License Warning Banner
-
-When telemetry uploads fail for more than 4 days, users will see a prominent warning banner in the OpenHands Enterprise UI:
-
-```
-⚠️ Your OpenHands Enterprise license will expire in 30 days. Please contact support if this issue persists.
-```
-
-The banner appears at the top of all pages and cannot be permanently dismissed while the condition persists. Users can temporarily dismiss it, but it will reappear on page refresh until telemetry uploads resume successfully.
-
-### 2.2 Administrator Experience
-
-System administrators will not need to configure the telemetry system manually. The service automatically:
-
-1. **Detects OHE installations** using existing required environment variables (`GITHUB_APP_CLIENT_ID`, `KEYCLOAK_SERVER_URL`, etc.)
-
-2. **Generates unique customer identifiers** using administrator contact information:
-   - Customer email: Determined by the following priority order:
-     1. `OPENHANDS_ADMIN_EMAIL` environment variable (if set in helm values)
-     2. Email of the first user who accepted Terms of Service (earliest `accepted_tos` timestamp)
-   - Instance ID: Automatically generated by Replicated SDK using machine fingerprinting (IOPlatformUUID on macOS, D-Bus machine ID on Linux, Machine GUID on Windows)
-   - **No Fallback**: If neither email source is available, telemetry collection is skipped until at least one user exists
-
-3. **Collects and uploads metrics transparently** in the background via weekly collection and daily upload cronjobs
-
-4. **Displays warnings only when necessary** for license compliance - no notifications appear during normal operation
-
-## 3. Other Context
-
-### 3.1 Replicated Platform Integration
-
-The Replicated platform provides vendor-hosted infrastructure for collecting customer and instance telemetry. The Python SDK handles authentication, state management, and reliable metric delivery. Key concepts:
-
-- **Customer**: Represents a unique OHE installation, identified by email or installation fingerprint
-- **Instance**: Represents a specific deployment of OHE for a customer
-- **Metrics**: Custom key-value data points collected from the installation
-- **Status**: Instance health indicators (running, degraded, updating, etc.)
-
-The SDK automatically handles machine fingerprinting, local state caching, and retry logic for failed uploads.
-
-### 3.2 Administrator Email Detection Strategy
-
-To identify the appropriate administrator contact for sales outreach, the system uses a three-tier approach that avoids performance penalties on user authentication:
-
-**Tier 1: Explicit Configuration** - The `OPENHANDS_ADMIN_EMAIL` environment variable allows administrators to explicitly specify the contact email during deployment.
-
-**Tier 2: First Active User Detection** - If no explicit email is configured, the system identifies the first user who accepted Terms of Service (earliest `accepted_tos` timestamp with a valid email). This represents the first person to actively engage with the system and is very likely the administrator or installer.
-
-**No Fallback Needed** - If neither email source is available, telemetry collection is skipped entirely. This ensures we only report meaningful usage data when there are actual active users.
-
-**Performance Optimization**: The admin email determination is performed only during telemetry upload attempts, ensuring zero performance impact on user login flows.
-
-### 3.3 Metrics Collection Framework
-
-The proposed collector framework allows developers to define metrics in a single file change:
-
-```python
-@register_collector("user_activity")
-class UserActivityCollector(MetricsCollector):
-    def collect(self) -> Dict[str, Any]:
-        # Query database and return metrics
-        return {"active_users_7d": count, "conversations_created": total}
-```
-
-Collectors are automatically discovered and executed by the collection cronjob, making the system extensible without modifying core collection logic.
-
-## 4. Technical Design
-
-### 4.1 Database Schema
-
-#### 4.1.1 Telemetry Metrics Table
-
-Stores collected metrics with transmission status tracking:
-
-```sql
-CREATE TABLE telemetry_metrics (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    collected_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    metrics_data JSONB NOT NULL,
-    uploaded_at TIMESTAMP WITH TIME ZONE NULL,
-    upload_attempts INTEGER DEFAULT 0,
-    last_upload_error TEXT NULL,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE INDEX idx_telemetry_metrics_collected_at ON telemetry_metrics(collected_at);
-CREATE INDEX idx_telemetry_metrics_uploaded_at ON telemetry_metrics(uploaded_at);
-```
-
-#### 4.1.2 Telemetry Identity Table
-
-Stores persistent identity information that must survive container restarts:
-
-```sql
-CREATE TABLE telemetry_identity (
-    id INTEGER PRIMARY KEY DEFAULT 1,
-    customer_id VARCHAR(255) NULL,
-    instance_id VARCHAR(255) NULL,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    CONSTRAINT single_identity_row CHECK (id = 1)
-);
-```
-
-**Design Rationale:**
-- **Separation of Concerns**: Identity data (customer_id, instance_id) is separated from operational data
-- **Persistent vs Computed**: Only data that cannot be reliably recomputed is persisted
-- **Upload Tracking**: Upload timestamps are tied directly to the metrics they represent
-- **Simplified Queries**: System state can be derived from metrics table (e.g., `MAX(uploaded_at)` for last successful upload)
-
-### 4.2 Metrics Collection Framework
-
-#### 4.2.1 Base Collector Interface
-
-```python
-from abc import ABC, abstractmethod
-from typing import Dict, Any, List
-from dataclasses import dataclass
-
-@dataclass
-class MetricResult:
-    key: str
-    value: Any
-
-class MetricsCollector(ABC):
-    """Base class for metrics collectors."""
-
-    @abstractmethod
-    def collect(self) -> List[MetricResult]:
-        """Collect metrics and return results."""
-        pass
-
-    @property
-    @abstractmethod
-    def collector_name(self) -> str:
-        """Unique name for this collector."""
-        pass
-
-    def should_collect(self) -> bool:
-        """Override to add collection conditions."""
-        return True
-```
-
-#### 4.2.2 Collector Registry
-
-```python
-from typing import Dict, Type, List
-import importlib
-import pkgutil
-
-class CollectorRegistry:
-    """Registry for metrics collectors."""
-
-    def __init__(self):
-        self._collectors: Dict[str, Type[MetricsCollector]] = {}
-
-    def register(self, collector_class: Type[MetricsCollector]) -> None:
-        """Register a collector class."""
-        collector = collector_class()
-        self._collectors[collector.collector_name] = collector_class
-
-    def get_all_collectors(self) -> List[MetricsCollector]:
-        """Get instances of all registered collectors."""
-        return [cls() for cls in self._collectors.values()]
-
-    def discover_collectors(self, package_path: str) -> None:
-        """Auto-discover collectors in a package."""
-        # Implementation to scan for @register_collector decorators
-        pass
-
-# Global registry instance
-collector_registry = CollectorRegistry()
-
-def register_collector(name: str):
-    """Decorator to register a collector."""
-    def decorator(cls: Type[MetricsCollector]) -> Type[MetricsCollector]:
-        collector_registry.register(cls)
-        return cls
-    return decorator
-```
-
-#### 4.2.3 Example Collector Implementation
-
-```python
-@register_collector("system_metrics")
-class SystemMetricsCollector(MetricsCollector):
-    """Collects basic system and usage metrics."""
-
-    @property
-    def collector_name(self) -> str:
-        return "system_metrics"
-
-    def collect(self) -> List[MetricResult]:
-        results = []
-
-        # Collect user count
-        with session_maker() as session:
-            user_count = session.query(UserSettings).count()
-            results.append(MetricResult(
-                key="total_users",
-                value=user_count
-            ))
-
-            # Collect conversation count (last 30 days)
-            thirty_days_ago = datetime.now(timezone.utc) - timedelta(days=30)
-            conversation_count = session.query(StoredConversationMetadata)\
-                .filter(StoredConversationMetadata.created_at >= thirty_days_ago)\
-                .count()
-
-            results.append(MetricResult(
-                key="conversations_30d",
-                value=conversation_count
-            ))
-
-        return results
-```
-
-### 4.3 Collection and Upload System
-
-#### 4.3.1 Metrics Collection Processor
-
-```python
-class TelemetryCollectionProcessor(MaintenanceTaskProcessor):
-    """Maintenance task processor for collecting metrics."""
-
-    collection_interval_days: int = 7
-
-    async def __call__(self, task: MaintenanceTask) -> dict:
-        """Collect metrics from all registered collectors."""
-
-        # Check if collection is needed
-        if not self._should_collect():
-            return {"status": "skipped", "reason": "too_recent"}
-
-        # Collect metrics from all registered collectors
-        all_metrics = {}
-        collector_results = {}
-
-        for collector in collector_registry.get_all_collectors():
-            try:
-                if collector.should_collect():
-                    results = collector.collect()
-                    for result in results:
-                        all_metrics[result.key] = result.value
-                    collector_results[collector.collector_name] = len(results)
-            except Exception as e:
-                logger.error(f"Collector {collector.collector_name} failed: {e}")
-                collector_results[collector.collector_name] = f"error: {e}"
-
-        # Store metrics in database
-        with session_maker() as session:
-            telemetry_record = TelemetryMetrics(
-                metrics_data=all_metrics,
-                collected_at=datetime.now(timezone.utc)
-            )
-            session.add(telemetry_record)
-            session.commit()
-
-            # Note: No need to track last_collection_at separately
-            # Can be derived from MAX(collected_at) in telemetry_metrics
-
-        return {
-            "status": "completed",
-            "metrics_collected": len(all_metrics),
-            "collectors_run": collector_results
-        }
-
-    def _should_collect(self) -> bool:
-        """Check if collection is needed based on interval."""
-        with session_maker() as session:
-            # Get last collection time from metrics table
-            last_collected = session.query(func.max(TelemetryMetrics.collected_at)).scalar()
-            if not last_collected:
-                return True
-
-            time_since_last = datetime.now(timezone.utc) - last_collected
-            return time_since_last.days >= self.collection_interval_days
-```
-
-#### 4.3.2 Replicated Upload Processor
-
-```python
-from replicated import AsyncReplicatedClient, InstanceStatus
-
-class TelemetryUploadProcessor(MaintenanceTaskProcessor):
-    """Maintenance task processor for uploading metrics to Replicated."""
-
-    replicated_publishable_key: str
-    replicated_app_slug: str
-
-    async def __call__(self, task: MaintenanceTask) -> dict:
-        """Upload pending metrics to Replicated."""
-
-        # Get pending metrics
-        with session_maker() as session:
-            pending_metrics = session.query(TelemetryMetrics)\
-                .filter(TelemetryMetrics.uploaded_at.is_(None))\
-                .order_by(TelemetryMetrics.collected_at)\
-                .all()
-
-        if not pending_metrics:
-            return {"status": "no_pending_metrics"}
-
-        # Get admin email - skip if not available
-        admin_email = self._get_admin_email()
-        if not admin_email:
-            logger.info("Skipping telemetry upload - no admin email available")
-            return {
-                "status": "skipped",
-                "reason": "no_admin_email",
-                "total_processed": 0
-            }
-
-        uploaded_count = 0
-        failed_count = 0
-
-        async with AsyncReplicatedClient(
-            publishable_key=self.replicated_publishable_key,
-            app_slug=self.replicated_app_slug
-        ) as client:
-
-            # Get or create customer and instance
-            customer = await client.customer.get_or_create(
-                email_address=admin_email
-            )
-            instance = await customer.get_or_create_instance()
-
-            # Store customer/instance IDs for future use
-            await self._update_telemetry_identity(customer.customer_id, instance.instance_id)
-
-            # Upload each metric batch
-            for metric_record in pending_metrics:
-                try:
-                    # Send individual metrics
-                    for key, value in metric_record.metrics_data.items():
-                        await instance.send_metric(key, value)
-
-                    # Update instance status
-                    await instance.set_status(InstanceStatus.RUNNING)
-
-                    # Mark as uploaded
-                    with session_maker() as session:
-                        record = session.query(TelemetryMetrics)\
-                            .filter(TelemetryMetrics.id == metric_record.id)\
-                            .first()
-                        if record:
-                            record.uploaded_at = datetime.now(timezone.utc)
-                            session.commit()
-
-                    uploaded_count += 1
-
-                except Exception as e:
-                    logger.error(f"Failed to upload metrics {metric_record.id}: {e}")
-
-                    # Update error info
-                    with session_maker() as session:
-                        record = session.query(TelemetryMetrics)\
-                            .filter(TelemetryMetrics.id == metric_record.id)\
-                            .first()
-                        if record:
-                            record.upload_attempts += 1
-                            record.last_upload_error = str(e)
-                            session.commit()
-
-                    failed_count += 1
-
-        # Note: No need to track last_successful_upload_at separately
-        # Can be derived from MAX(uploaded_at) in telemetry_metrics
-
-        return {
-            "status": "completed",
-            "uploaded": uploaded_count,
-            "failed": failed_count,
-            "total_processed": len(pending_metrics)
-        }
-
-    def _get_admin_email(self) -> str | None:
-        """Get administrator email for customer identification."""
-        # 1. Check environment variable first
-        env_admin_email = os.getenv('OPENHANDS_ADMIN_EMAIL')
-        if env_admin_email:
-            logger.info("Using admin email from environment variable")
-            return env_admin_email
-
-        # 2. Use first active user's email (earliest accepted_tos)
-        with session_maker() as session:
-            first_user = session.query(UserSettings)\
-                .filter(UserSettings.email.isnot(None))\
-                .filter(UserSettings.accepted_tos.isnot(None))\
-                .order_by(UserSettings.accepted_tos.asc())\
-                .first()
-
-            if first_user and first_user.email:
-                logger.info(f"Using first active user email: {first_user.email}")
-                return first_user.email
-
-        # No admin email available - skip telemetry
-        logger.info("No admin email available - skipping telemetry collection")
-        return None
-
-    async def _update_telemetry_identity(self, customer_id: str, instance_id: str) -> None:
-        """Update or create telemetry identity record."""
-        with session_maker() as session:
-            identity = session.query(TelemetryIdentity).first()
-            if not identity:
-                identity = TelemetryIdentity()
-                session.add(identity)
-
-            identity.customer_id = customer_id
-            identity.instance_id = instance_id
-            session.commit()
-```
-
-### 4.4 License Warning System
-
-#### 4.4.1 License Status Endpoint
-
-```python
-from fastapi import APIRouter
-from datetime import datetime, timezone, timedelta
-
-license_router = APIRouter()
-
-@license_router.get("/license-status")
-async def get_license_status():
-    """Get license warning status for UI display."""
-
-    # Only show warnings for OHE installations
-    if not _is_openhands_enterprise():
-        return {"warn": False, "message": ""}
-
-    with session_maker() as session:
-        # Get last successful upload time from metrics table
-        last_upload = session.query(func.max(TelemetryMetrics.uploaded_at))\
-            .filter(TelemetryMetrics.uploaded_at.isnot(None))\
-            .scalar()
-
-        if not last_upload:
-            # No successful uploads yet - show warning after 4 days
-            return {
-                "warn": True,
-                "message": "OpenHands Enterprise license verification pending. Please ensure network connectivity."
-            }
-
-        # Check if last successful upload was more than 4 days ago
-        days_since_upload = (datetime.now(timezone.utc) - last_upload).days
-
-        if days_since_upload > 4:
-            # Find oldest unsent batch
-            oldest_unsent = session.query(TelemetryMetrics)\
-                .filter(TelemetryMetrics.uploaded_at.is_(None))\
-                .order_by(TelemetryMetrics.collected_at)\
-                .first()
-
-            if oldest_unsent:
-                # Calculate expiration date (oldest unsent + 34 days)
-                expiration_date = oldest_unsent.collected_at + timedelta(days=34)
-                days_until_expiration = (expiration_date - datetime.now(timezone.utc)).days
-
-                if days_until_expiration <= 0:
-                    message = "Your OpenHands Enterprise license has expired. Please contact support immediately."
-                else:
-                    message = f"Your OpenHands Enterprise license will expire in {days_until_expiration} days. Please contact support if this issue persists."
-
-                return {"warn": True, "message": message}
-
-        return {"warn": False, "message": ""}
-
-def _is_openhands_enterprise() -> bool:
-    """Detect if this is an OHE installation."""
-    # Check for required OHE environment variables
-    required_vars = [
-        'GITHUB_APP_CLIENT_ID',
-        'KEYCLOAK_SERVER_URL',
-        'KEYCLOAK_REALM_NAME'
-    ]
-
-    return all(os.getenv(var) for var in required_vars)
-```
-
-#### 4.4.2 UI Integration
-
-The frontend will poll the license status endpoint and display warnings using the existing banner component pattern:
-
-```typescript
-// New component: LicenseWarningBanner.tsx
-interface LicenseStatus {
-  warn: boolean;
-  message: string;
-}
-
-export function LicenseWarningBanner() {
-  const [licenseStatus, setLicenseStatus] = useState<LicenseStatus>({ warn: false, message: "" });
-
-  useEffect(() => {
-    const checkLicenseStatus = async () => {
-      try {
-        const response = await fetch('/api/license-status');
-        const status = await response.json();
-        setLicenseStatus(status);
-      } catch (error) {
-        console.error('Failed to check license status:', error);
-      }
-    };
-
-    // Check immediately and then every hour
-    checkLicenseStatus();
-    const interval = setInterval(checkLicenseStatus, 60 * 60 * 1000);
-
-    return () => clearInterval(interval);
-  }, []);
-
-  if (!licenseStatus.warn) {
-    return null;
-  }
-
-  return (
-    <div className="bg-red-600 text-white p-4 rounded flex items-center justify-between">
-      <div className="flex items-center">
-        <FaExclamationTriangle className="mr-3" />
-        <span>{licenseStatus.message}</span>
-      </div>
-    </div>
-  );
-}
-```
-
-### 4.5 Cronjob Configuration
-
-The cronjob configurations will be deployed via the OpenHands-Cloud helm charts.
-
-#### 4.5.1 Collection Cronjob
-
-The collection cronjob runs weekly to gather metrics:
-
-```yaml
-# charts/openhands/templates/telemetry-collection-cronjob.yaml
-apiVersion: batch/v1
-kind: CronJob
-metadata:
-  name: {{ include "openhands.fullname" . }}-telemetry-collection
-  labels:
-    {{- include "openhands.labels" . | nindent 4 }}
-spec:
-  schedule: "0 2 * * 0"  # Weekly on Sunday at 2 AM
-  jobTemplate:
-    spec:
-      template:
-        spec:
-          containers:
-          - name: telemetry-collector
-            image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
-            env:
-            {{- include "openhands.env" . | nindent 12 }}
-            command:
-            - python
-            - -c
-            - |
-              from enterprise.storage.maintenance_task import MaintenanceTask, MaintenanceTaskStatus
-              from enterprise.storage.database import session_maker
-              from enterprise.server.telemetry.collection_processor import TelemetryCollectionProcessor
-
-              # Create collection task
-              processor = TelemetryCollectionProcessor()
-              task = MaintenanceTask()
-              task.set_processor(processor)
-              task.status = MaintenanceTaskStatus.PENDING
-
-              with session_maker() as session:
-                  session.add(task)
-                  session.commit()
-          restartPolicy: OnFailure
-```
-
-#### 4.5.2 Upload Cronjob
-
-The upload cronjob runs daily to send metrics to Replicated:
-
-```yaml
-# charts/openhands/templates/telemetry-upload-cronjob.yaml
-apiVersion: batch/v1
-kind: CronJob
-metadata:
-  name: {{ include "openhands.fullname" . }}-telemetry-upload
-  labels:
-    {{- include "openhands.labels" . | nindent 4 }}
-spec:
-  schedule: "0 3 * * *"  # Daily at 3 AM
-  jobTemplate:
-    spec:
-      template:
-        spec:
-          containers:
-          - name: telemetry-uploader
-            image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
-            env:
-            {{- include "openhands.env" . | nindent 12 }}
-            - name: REPLICATED_PUBLISHABLE_KEY
-              valueFrom:
-                secretKeyRef:
-                  name: {{ include "openhands.fullname" . }}-replicated-config
-                  key: publishable-key
-            - name: REPLICATED_APP_SLUG
-              value: {{ .Values.telemetry.replicatedAppSlug | default "openhands-enterprise" | quote }}
-            command:
-            - python
-            - -c
-            - |
-              from enterprise.storage.maintenance_task import MaintenanceTask, MaintenanceTaskStatus
-              from enterprise.storage.database import session_maker
-              from enterprise.server.telemetry.upload_processor import TelemetryUploadProcessor
-              import os
-
-              # Create upload task
-              processor = TelemetryUploadProcessor(
-                  replicated_publishable_key=os.getenv('REPLICATED_PUBLISHABLE_KEY'),
-                  replicated_app_slug=os.getenv('REPLICATED_APP_SLUG', 'openhands-enterprise')
-              )
-              task = MaintenanceTask()
-              task.set_processor(processor)
-              task.status = MaintenanceTaskStatus.PENDING
-
-              with session_maker() as session:
-                  session.add(task)
-                  session.commit()
-          restartPolicy: OnFailure
-```
-
-## 5. Implementation Plan
-
-All implementation must pass existing lints and tests. New functionality requires comprehensive unit tests with >90% coverage. Integration tests should verify end-to-end telemetry flow including collection, storage, upload, and warning display.
-
-### 5.1 Database Schema and Models (M1)
-
-**Repository**: OpenHands
-Establish the foundational database schema and SQLAlchemy models for telemetry data storage.
-
-#### 5.1.1 OpenHands - Database Migration
-
-- [ ] `enterprise/migrations/versions/077_create_telemetry_tables.py`
-- [ ] `enterprise/storage/telemetry_metrics.py`
-- [ ] `enterprise/storage/telemetry_config.py`
-
-#### 5.1.2 OpenHands - Model Tests
-
-- [ ] `enterprise/tests/unit/storage/test_telemetry_metrics.py`
-- [ ] `enterprise/tests/unit/storage/test_telemetry_config.py`
-
-**Demo**: Database tables created and models can store/retrieve telemetry data.
-
-### 5.2 Metrics Collection Framework (M2)
-
-**Repository**: OpenHands
-Implement the pluggable metrics collection system with registry and base classes.
-
-#### 5.2.1 OpenHands - Core Collection Framework
-
-- [ ] `enterprise/server/telemetry/__init__.py`
-- [ ] `enterprise/server/telemetry/collector_base.py`
-- [ ] `enterprise/server/telemetry/collector_registry.py`
-- [ ] `enterprise/server/telemetry/decorators.py`
-
-#### 5.2.2 OpenHands - Example Collectors
-
-- [ ] `enterprise/server/telemetry/collectors/__init__.py`
-- [ ] `enterprise/server/telemetry/collectors/system_metrics.py`
-- [ ] `enterprise/server/telemetry/collectors/user_activity.py`
-
-#### 5.2.3 OpenHands - Framework Tests
-
-- [ ] `enterprise/tests/unit/telemetry/test_collector_base.py`
-- [ ] `enterprise/tests/unit/telemetry/test_collector_registry.py`
-- [ ] `enterprise/tests/unit/telemetry/test_system_metrics.py`
-
-**Demo**: Developers can create new collectors with a single file change using the @register_collector decorator.
-
-### 5.3 Collection and Upload Processors (M3)
-
-**Repository**: OpenHands
-Implement maintenance task processors for collecting metrics and uploading to Replicated.
-
-#### 5.3.1 OpenHands - Collection Processor
-
-- [ ] `enterprise/server/telemetry/collection_processor.py`
-- [ ] `enterprise/tests/unit/telemetry/test_collection_processor.py`
-
-#### 5.3.2 OpenHands - Upload Processor
-
-- [ ] `enterprise/server/telemetry/upload_processor.py`
-- [ ] `enterprise/tests/unit/telemetry/test_upload_processor.py`
-
-#### 5.3.3 OpenHands - Integration Tests
-
-- [ ] `enterprise/tests/integration/test_telemetry_flow.py`
-
-**Demo**: Metrics are automatically collected weekly and uploaded daily to Replicated vendor portal.
-
-### 5.4 License Warning API (M4)
-
-**Repository**: OpenHands
-Implement the license status endpoint for the warning system.
-
-#### 5.4.1 OpenHands - License Status API
-
-- [ ] `enterprise/server/routes/license.py`
-- [ ] `enterprise/tests/unit/routes/test_license.py`
-
-#### 5.4.2 OpenHands - API Integration
-
-- [ ] Update `enterprise/saas_server.py` to include license router
-
-**Demo**: License status API returns warning status based on telemetry upload success.
-
-### 5.5 UI Warning Banner (M5)
-
-**Repository**: OpenHands
-Implement the frontend warning banner component and integration.
-
-#### 5.5.1 OpenHands - UI Warning Banner
-
-- [ ] `frontend/src/components/features/license/license-warning-banner.tsx`
-- [ ] `frontend/src/components/features/license/license-warning-banner.test.tsx`
-
-#### 5.5.2 OpenHands - UI Integration
-
-- [ ] Update main UI layout to include license warning banner
-- [ ] Add license status polling service
-
-**Demo**: License warnings appear in UI when telemetry uploads fail for >4 days, with accurate expiration countdown.
-
-### 5.6 Helm Chart Deployment Configuration (M6)
-
-**Repository**: OpenHands-Cloud
-Create Kubernetes cronjob configurations and deployment scripts.
-
-#### 5.6.1 OpenHands-Cloud - Cronjob Manifests
-
-- [ ] `charts/openhands/templates/telemetry-collection-cronjob.yaml`
-- [ ] `charts/openhands/templates/telemetry-upload-cronjob.yaml`
-
-#### 5.6.2 OpenHands-Cloud - Configuration Management
-
-- [ ] `charts/openhands/templates/replicated-secret.yaml`
-- [ ] Update `charts/openhands/values.yaml` with telemetry configuration options:
-  ```yaml
-  # Add to values.yaml
-  telemetry:
-    enabled: true
-    replicatedAppSlug: "openhands-enterprise"
-    adminEmail: ""  # Optional: admin email for customer identification
-
-  # Add to deployment environment variables
-  env:
-    OPENHANDS_ADMIN_EMAIL: "{{ .Values.telemetry.adminEmail }}"
-  ```
-
-**Demo**: Complete telemetry system deployed via helm chart with configurable collection intervals and Replicated integration.
-
-### 5.7 Documentation and Enhanced Collectors (M7)
-
-**Repository**: OpenHands
-Add comprehensive metrics collectors, monitoring capabilities, and documentation.
-
-#### 5.7.1 OpenHands - Advanced Collectors
-
-- [ ] `enterprise/server/telemetry/collectors/conversation_metrics.py`
-- [ ] `enterprise/server/telemetry/collectors/integration_usage.py`
-- [ ] `enterprise/server/telemetry/collectors/performance_metrics.py`
-
-#### 5.7.2 OpenHands - Monitoring and Testing
-
-- [ ] `enterprise/server/telemetry/monitoring.py`
-- [ ] `enterprise/tests/e2e/test_telemetry_system.py`
-- [ ] Performance tests for large-scale metric collection
-
-#### 5.7.3 OpenHands - Technical Documentation
-
-- [ ] `enterprise/server/telemetry/README.md`
-- [ ] Update deployment documentation with telemetry configuration instructions
-- [ ] Add troubleshooting guide for telemetry issues
-
-**Demo**: Rich telemetry data flowing to vendor portal with comprehensive monitoring, alerting for system health, and complete documentation.

enterprise/downgrade_migrated_users.py

@@ -1,207 +0,0 @@
-#!/usr/bin/env python
-"""
-This script can be removed once orgs is established - probably after Feb 15 2026
-
-Downgrade script for migrated users.
-
-This script identifies users who have been migrated (already_migrated=True)
-and reverts them back to the pre-migration state.
-
-Usage:
-    # Dry run - just list the users that would be downgraded
-    python downgrade_migrated_users.py --dry-run
-
-    # Downgrade a specific user by their keycloak_user_id
-    python downgrade_migrated_users.py --user-id <user_id>
-
-    # Downgrade all migrated users (with confirmation)
-    python downgrade_migrated_users.py --all
-
-    # Downgrade all migrated users without confirmation (dangerous!)
-    python downgrade_migrated_users.py --all --no-confirm
-"""
-
-import argparse
-import asyncio
-import sys
-
-# Add the enterprise directory to the path
-sys.path.insert(0, '/workspace/project/OpenHands/enterprise')
-
-from server.logger import logger
-from sqlalchemy import select, text
-from storage.database import session_maker
-from storage.user_settings import UserSettings
-from storage.user_store import UserStore
-
-
-def get_migrated_users() -> list[str]:
-    """Get list of keycloak_user_ids for users who have been migrated.
-
-    This includes:
-    1. Users with already_migrated=True in user_settings (migrated users)
-    2. Users in the 'user' table who don't have a user_settings entry (new sign-ups)
-    """
-    with session_maker() as session:
-        # Get users from user_settings with already_migrated=True
-        migrated_result = session.execute(
-            select(UserSettings.keycloak_user_id).where(
-                UserSettings.already_migrated.is_(True)
-            )
-        )
-        migrated_users = {row[0] for row in migrated_result.fetchall() if row[0]}
-
-        # Get users from the 'user' table (new sign-ups won't have user_settings)
-        # These are users who signed up after the migration was deployed
-        new_signup_result = session.execute(
-            text("""
-                SELECT CAST(u.id AS VARCHAR)
-                FROM "user" u
-                WHERE NOT EXISTS (
-                    SELECT 1 FROM user_settings us
-                    WHERE us.keycloak_user_id = CAST(u.id AS VARCHAR)
-                )
-            """)
-        )
-        new_signups = {row[0] for row in new_signup_result.fetchall() if row[0]}
-
-        # Combine both sets
-        all_users = migrated_users | new_signups
-        return list(all_users)
-
-
-async def downgrade_user(user_id: str) -> bool:
-    """Downgrade a single user.
-
-    Args:
-        user_id: The keycloak_user_id to downgrade
-
-    Returns:
-        True if successful, False otherwise
-    """
-    try:
-        result = await UserStore.downgrade_user(user_id)
-        if result:
-            print(f'✓ Successfully downgraded user: {user_id}')
-            return True
-        else:
-            print(f'✗ Failed to downgrade user: {user_id}')
-            return False
-    except Exception as e:
-        print(f'✗ Error downgrading user {user_id}: {e}')
-        logger.exception(
-            'downgrade_script:error',
-            extra={'user_id': user_id, 'error': str(e)},
-        )
-        return False
-
-
-async def main():
-    parser = argparse.ArgumentParser(
-        description='Downgrade migrated users back to pre-migration state'
-    )
-    parser.add_argument(
-        '--dry-run',
-        action='store_true',
-        help='Just list users that would be downgraded, without making changes',
-    )
-    parser.add_argument(
-        '--user-id',
-        type=str,
-        help='Downgrade a specific user by keycloak_user_id',
-    )
-    parser.add_argument(
-        '--all',
-        action='store_true',
-        help='Downgrade all migrated users',
-    )
-    parser.add_argument(
-        '--no-confirm',
-        action='store_true',
-        help='Skip confirmation prompt (use with caution!)',
-    )
-
-    args = parser.parse_args()
-
-    # Get list of migrated users
-    migrated_users = get_migrated_users()
-    print(f'\nFound {len(migrated_users)} migrated user(s).')
-
-    if args.dry_run:
-        print('\n--- DRY RUN MODE ---')
-        print('The following users would be downgraded:')
-        for user_id in migrated_users:
-            print(f'  - {user_id}')
-        print('\nNo changes were made.')
-        return
-
-    if args.user_id:
-        # Downgrade a specific user
-        if args.user_id not in migrated_users:
-            print(f'\nUser {args.user_id} is not in the migrated users list.')
-            print('Either the user was not migrated, or the user_id is incorrect.')
-            return
-
-        print(f'\nDowngrading user: {args.user_id}')
-        if not args.no_confirm:
-            confirm = input('Are you sure? (yes/no): ')
-            if confirm.lower() != 'yes':
-                print('Cancelled.')
-                return
-
-        success = await downgrade_user(args.user_id)
-        if success:
-            print('\nDowngrade completed successfully.')
-        else:
-            print('\nDowngrade failed. Check logs for details.')
-            sys.exit(1)
-
-    elif args.all:
-        # Downgrade all migrated users
-        if not migrated_users:
-            print('\nNo migrated users to downgrade.')
-            return
-
-        print(f'\n⚠️  About to downgrade {len(migrated_users)} user(s).')
-        if not args.no_confirm:
-            print('\nThis will:')
-            print('  - Revert LiteLLM team/user budget settings')
-            print('  - Delete organization entries')
-            print('  - Delete user entries in the new schema')
-            print('  - Reset the already_migrated flag')
-            print('\nUsers to downgrade:')
-            for user_id in migrated_users[:10]:  # Show first 10
-                print(f'  - {user_id}')
-            if len(migrated_users) > 10:
-                print(f'  ... and {len(migrated_users) - 10} more')
-
-            confirm = input('\nType "yes" to proceed: ')
-            if confirm.lower() != 'yes':
-                print('Cancelled.')
-                return
-
-        print('\nStarting downgrade...\n')
-        success_count = 0
-        fail_count = 0
-
-        for user_id in migrated_users:
-            success = await downgrade_user(user_id)
-            if success:
-                success_count += 1
-            else:
-                fail_count += 1
-
-        print('\n--- Summary ---')
-        print(f'Successful: {success_count}')
-        print(f'Failed: {fail_count}')
-
-        if fail_count > 0:
-            sys.exit(1)
-
-    else:
-        parser.print_help()
-        print('\nPlease specify --dry-run, --user-id, or --all')
-
-
-if __name__ == '__main__':
-    asyncio.run(main())

enterprise/enterprise_local/README.md

@@ -1,274 +0,0 @@
-# Instructions for developing SAAS locally
-
-You have a few options here, which are expanded on below:
-
-- A simple local development setup, with live reloading for both OpenHands and this repo
-- A more complex setup that includes Redis
-- An even more complex setup that includes GitHub events
-
-## Prerequisites
-
-Before starting, make sure you have the following tools installed:
-
-### Required for all options:
-
-- [gcloud CLI](https://cloud.google.com/sdk/docs/install) - For authentication and secrets management
-- [sops](https://github.com/mozilla/sops) - For secrets decryption
-  - macOS: `brew install sops`
-  - Linux: `sudo apt-get install sops` or download from GitHub releases
-  - Windows: Install via Chocolatey `choco install sops` or download from GitHub releases
-
-### Additional requirements for enabling GitHub webhook events
-
-- make
-- Python development tools (build-essential, python3-dev)
-- [ngrok](https://ngrok.com/download) - For creating tunnels to localhost
-
-## Option 1: Simple local development
-
-This option will allow you to modify both the OpenHands code and the code in this repo,
-and see the changes in real-time.
-
-This option works best for most scenarios. The only thing it's missing is
-the GitHub events webhook, which is not necessary for most development.
-
-### 1. OpenHands location
-
-The open source OpenHands repo should be cloned as a sibling directory,
-in `../OpenHands`. This is hard-coded in the pyproject.toml (edit if necessary)
-
-If you're doing this the first time, you may need to run
-
-```
-poetry update openhands-ai
-```
-
-### 2. Set up env
-
-First run this to retrieve Github App secrets
-
-```
-gcloud auth application-default login
-gcloud config set project global-432717
-enterprise_local/decrypt_env.sh /path/to/root/of/deploy/repo
-```
-
-Now run this to generate a `.env` file, which will used to run SAAS locally
-
-```
-python -m pip install PyYAML
-export LITE_LLM_API_KEY=<your LLM API key>
-python enterprise_local/convert_to_env.py
-```
-
-You'll also need to set up the runtime image, so that the dev server doesn't try to rebuild it.
-
-```
-export SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/openhands/runtime:main-nikolaik
-docker pull $SANDBOX_RUNTIME_CONTAINER_IMAGE
-```
-
-By default the application will log in json, you can override.
-
-```
-export LOG_PLAIN_TEXT=1
-```
-
-### 3. Start the OpenHands frontend
-
-Start the frontend like you normally would in the open source OpenHands repo.
-
-### 4. Start the SaaS backend
-
-```
-make build
-
-make start-backend
-```
-
-You should have a server running on `localhost:3000`, similar to the open source backend.
-Oauth should work properly.
-
-## Option 2: With Redis
-
-Follow all the steps above, then setup redis:
-
-```bash
-docker run  -p 6379:6379 --name openhands-redis -d redis
-export REDIS_HOST=host.docker.internal # you may want this to be localhost
-export REDIS_PORT=6379
-```
-
-## Option 3: Work with GitHub events
-
-### 1. Setup env file
-
-(see above)
-
-### 2. Build OpenHands
-
-Develop on [Openhands](https://github.com/OpenHands/OpenHands) locally. When ready, run the following inside Openhands repo (not the Deploy repo)
-
-```
-docker build -f containers/app/Dockerfile -t openhands .
-```
-
-### 3. Build SAAS Openhands
-
-Build the SAAS image locally inside Deploy repo. Note that `openhands` is the name of the image built in Step 2
-
-```
-docker build -t openhands-saas ./app/ --build-arg BASE="openhands"
-```
-
-### 4. Create a tunnel
-
-Run in a separate terminal
-
-```
-ngrok http 3000
-```
-
-There will be a line
-
-```
-Forwarding                    https://bc71-2603-7000-5000-1575-e4a6-697b-589e-5801.ngrok-free.app
-```
-
-Remember this URL as it will be used in Step 5 and 6
-
-### 5. Setup Staging Github App callback/webhook urls
-
-Using the URL found in Step 4, add another callback URL (`https://bc71-2603-7000-5000-1575-e4a6-697b-589e-5801.ngrok-free.app/oauth/github/callback`)
-
-### 6. Run
-
-This is the last step! Run SAAS openhands locally using
-
-```
-docker run --env-file ./app/.env -p 3000:3000 openhands-saas
-```
-
-Note `--env-file` is what injects the `.env` file created in Step 1
-
-Visit the tunnel domain found in Step 4 to run the app (`https://bc71-2603-7000-5000-1575-e4a6-697b-589e-5801.ngrok-free.app`)
-
-### Local Debugging with VSCode
-
-Local Development necessitates running a version of OpenHands that is as similar as possible to the version running in the SAAS Environment. Before running these steps, it is assumed you have a local development version of OpenHands running.
-
-#### Redis
-
-A Local redis instance is required for clustered communication between server nodes. The standard docker instance will suffice.
-`docker run -it -p 6379:6379 --name my-redis -d redis`
-
-#### Postgres
-
-A Local postgres instance is required. I used the official docker image:
-`docker run -p 5432:5432 --name my-postgres -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=openhands -d postgres`
-Run the alembic migrations:
-`poetry run alembic upgrade head `
-
-#### VSCode launch.json
-
-The VSCode launch.json below sets up 2 servers to test clustering, running independently on localhost:3030 and localhost:3031. Running only the server on 3030 is usually sufficient unless tests of the clustered functionality are required. Secrets may be harvested directly from staging by connecting...
-`kubectl exec --stdin --tty <POD_NAME> -n <NAMESPACE> -- /bin/bash`
-And then invoking `printenv`. NOTE: _DO NOT DO THIS WITH PROD!!!_ (Hopefully by the time you read this, nobody will have access.)
-
-```
-{
-    "configurations": [
-        {
-            "name": "Python Debugger: Python File",
-            "type": "debugpy",
-            "request": "launch",
-            "program": "${file}"
-        },
-        {
-            "name": "OpenHands Deploy",
-            "type": "debugpy",
-            "request": "launch",
-            "module": "uvicorn",
-            "args": [
-                "saas_server:app",
-                "--reload",
-                "--host",
-                "0.0.0.0",
-                "--port",
-                "3030"
-            ],
-            "env": {
-                "DEBUG": "1",
-                "FILE_STORE": "local",
-                "REDIS_HOST": "localhost:6379",
-                "OPENHANDS": "<YOUR LOCAL OPENHANDS DIR>",
-                "FRONTEND_DIRECTORY": "<YOUR LOCAL OPENHANDS DIR>/frontend/build",
-                "SANDBOX_RUNTIME_CONTAINER_IMAGE": "ghcr.io/openhands/runtime:main-nikolaik",
-                "FILE_STORE_PATH": "<YOUR HOME DIRECTORY>>/.openhands-state",
-                "OPENHANDS_CONFIG_CLS": "server.config.SaaSServerConfig",
-                "GITHUB_APP_ID": "1062351",
-                "GITHUB_APP_PRIVATE_KEY": "<GITHUB PRIVATE KEY>",
-                "GITHUB_APP_CLIENT_ID": "Iv23lis7eUWDQHIq8US0",
-                "GITHUB_APP_CLIENT_SECRET": "<GITHUB CLIENT SECRET>",
-                "POSTHOG_CLIENT_KEY": "<POSTHOG CLIENT KEY>",
-                "LITE_LLM_API_URL": "https://llm-proxy.staging.all-hands.dev",
-                "LITE_LLM_TEAM_ID": "62ea39c4-8886-44f3-b7ce-07ed4fe42d2c",
-                "LITE_LLM_API_KEY": "<LITE LLM API KEY>"
-            },
-            "justMyCode": false,
-            "cwd": "${workspaceFolder}/app"
-        },
-        {
-            "name": "OpenHands Deploy 2",
-            "type": "debugpy",
-            "request": "launch",
-            "module": "uvicorn",
-            "args": [
-                "saas_server:app",
-                "--reload",
-                "--host",
-                "0.0.0.0",
-                "--port",
-                "3031"
-            ],
-            "env": {
-                "DEBUG": "1",
-                "FILE_STORE": "local",
-                "REDIS_HOST": "localhost:6379",
-                "OPENHANDS": "<YOUR LOCAL OPENHANDS DIR>",
-                "FRONTEND_DIRECTORY": "<YOUR LOCAL OPENHANDS DIR>/frontend/build",
-                "SANDBOX_RUNTIME_CONTAINER_IMAGE": "ghcr.io/openhands/runtime:main-nikolaik",
-                "FILE_STORE_PATH": "<YOUR HOME DIRECTORY>>/.openhands-state",
-                "OPENHANDS_CONFIG_CLS": "server.config.SaaSServerConfig",
-                "GITHUB_APP_ID": "1062351",
-                "GITHUB_APP_PRIVATE_KEY": "<GITHUB PRIVATE KEY>",
-                "GITHUB_APP_CLIENT_ID": "Iv23lis7eUWDQHIq8US0",
-                "GITHUB_APP_CLIENT_SECRET": "<GITHUB CLIENT SECRET>",
-                "POSTHOG_CLIENT_KEY": "<POSTHOG CLIENT KEY>",
-                "LITE_LLM_API_URL": "https://llm-proxy.staging.all-hands.dev",
-                "LITE_LLM_TEAM_ID": "62ea39c4-8886-44f3-b7ce-07ed4fe42d2c",
-                "LITE_LLM_API_KEY": "<LITE LLM API KEY>"
-            },
-            "justMyCode": false,
-            "cwd": "${workspaceFolder}/app"
-        },
-        {
-            "name": "Unit Tests",
-            "type": "debugpy",
-            "request": "launch",
-            "module": "pytest",
-            "args": [
-                "./tests/unit",
-                //"./tests/unit/test_clustered_conversation_manager.py",
-                "--durations=0"
-            ],
-            "env": {
-                "DEBUG": "1"
-            },
-            "justMyCode": false,
-            "cwd": "${workspaceFolder}/app"
-        },
-        // set working directory...
-    ]
-}
-```

enterprise/enterprise_local/convert_to_env.py

@@ -1,127 +0,0 @@
-import base64
-import os
-import sys
-
-import yaml
-
-
-def convert_yaml_to_env(yaml_file, target_parameters, output_env_file, prefix):
-    """Converts a YAML file into .env file format for specified target parameters under 'stringData' and 'data'.
-
-    :param yaml_file: Path to the YAML file.
-    :param target_parameters: List of keys to extract from the YAML file.
-    :param output_env_file: Path to the output .env file.
-    :param prefix: Prefix for environment variables.
-    """
-    try:
-        # Load the YAML file
-        with open(yaml_file, 'r') as file:
-            yaml_data = yaml.safe_load(file)
-
-        # Extract sections
-        string_data = yaml_data.get('stringData', None)
-        data = yaml_data.get('data', None)
-
-        if string_data:
-            env_source = string_data
-            process_base64 = False
-        elif data:
-            env_source = data
-            process_base64 = True
-        else:
-            print(
-                "Error: Neither 'stringData' nor 'data' section found in the YAML file."
-            )
-            return
-
-        env_lines = []
-
-        for param in target_parameters:
-            if param in env_source:
-                value = env_source[param]
-                if process_base64:
-                    try:
-                        decoded_value = base64.b64decode(value).decode('utf-8')
-                        formatted_value = (
-                            decoded_value.replace('\n', '\\n')
-                            if '\n' in decoded_value
-                            else decoded_value
-                        )
-                    except Exception as decode_error:
-                        print(f"Error decoding base64 for '{param}': {decode_error}")
-                        continue
-                else:
-                    formatted_value = (
-                        value.replace('\n', '\\n')
-                        if isinstance(value, str) and '\n' in value
-                        else value
-                    )
-
-                new_key = prefix + param.upper().replace('-', '_')
-                env_lines.append(f'{new_key}={formatted_value}')
-            else:
-                print(
-                    f"Warning: Parameter '{param}' not found in the selected section."
-                )
-
-        # Write to the .env file
-        with open(output_env_file, 'a') as env_file:
-            env_file.write('\n'.join(env_lines) + '\n')
-
-    except Exception as e:
-        print(f'Error: {e}')
-
-
-lite_llm_api_key = os.getenv('LITE_LLM_API_KEY')
-if not lite_llm_api_key:
-    print('Set the LITE_LLM_API_KEY environment variable to your API key')
-    sys.exit(1)
-
-yaml_file = 'github_decrypted.yaml'
-target_parameters = ['client-id', 'client-secret', 'webhook-secret', 'private-key']
-output_env_file = './enterprise/.env'
-
-if os.path.exists(output_env_file):
-    os.remove(output_env_file)
-convert_yaml_to_env(yaml_file, target_parameters, output_env_file, 'GITHUB_APP_')
-os.remove(yaml_file)
-
-yaml_file = 'keycloak_realm_decrypted.yaml'
-target_parameters = ['client-id', 'client-secret', 'provider-name', 'realm-name']
-convert_yaml_to_env(yaml_file, target_parameters, output_env_file, 'KEYCLOAK_')
-os.remove(yaml_file)
-
-yaml_file = 'keycloak_admin_decrypted.yaml'
-target_parameters = ['admin-password']
-convert_yaml_to_env(yaml_file, target_parameters, output_env_file, 'KEYCLOAK_')
-os.remove(yaml_file)
-
-lines = []
-lines.append('KEYCLOAK_SERVER_URL=https://auth.staging.all-hands.dev/')
-lines.append('KEYCLOAK_SERVER_URL_EXT=https://auth.staging.all-hands.dev/')
-lines.append('OPENHANDS_CONFIG_CLS=server.config.SaaSServerConfig')
-lines.append(
-    'OPENHANDS_GITHUB_SERVICE_CLS=integrations.github.github_service.SaaSGitHubService'
-)
-lines.append(
-    'OPENHANDS_GITLAB_SERVICE_CLS=integrations.gitlab.gitlab_service.SaaSGitLabService'
-)
-lines.append(
-    'OPENHANDS_BITBUCKET_SERVICE_CLS=integrations.bitbucket.bitbucket_service.SaaSBitBucketService'
-)
-lines.append(
-    'OPENHANDS_CONVERSATION_VALIDATOR_CLS=storage.saas_conversation_validator.SaasConversationValidator'
-)
-lines.append('POSTHOG_CLIENT_KEY=test')
-lines.append('ENABLE_PROACTIVE_CONVERSATION_STARTERS=true')
-lines.append('MAX_CONCURRENT_CONVERSATIONS=10')
-lines.append('LITE_LLM_API_URL=https://llm-proxy.eval.all-hands.dev')
-lines.append('LITELLM_DEFAULT_MODEL=litellm_proxy/claude-opus-4-5-20251101')
-lines.append(f'LITE_LLM_API_KEY={lite_llm_api_key}')
-lines.append('LOCAL_DEPLOYMENT=true')
-lines.append('DB_HOST=localhost')
-
-with open(output_env_file, 'a') as env_file:
-    env_file.write('\n'.join(lines))
-
-print(f'.env file created at: {output_env_file}')

enterprise/enterprise_local/decrypt_env.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Check if DEPLOY_DIR argument was provided
-if [ $# -lt 1 ]; then
-  echo "Usage: $0 <DEPLOY_DIR>"
-  echo "Example: $0 /path/to/root/of/deploy/repo"
-  exit 1
-fi
-
-# Normalize path (remove trailing slash)
-DEPLOY_DIR="${1%/}"
-
-# Function to decrypt and rename
-decrypt_and_move() {
-  local secret_path="$1"
-  local output_name="$2"
-
-  ${DEPLOY_DIR}/scripts/decrypt.sh "${DEPLOY_DIR}/${secret_path}"
-  mv decrypted.yaml "${output_name}"
-  echo "Moved decrypted.yaml to ${output_name}"
-}
-
-# Decrypt each secret file
-decrypt_and_move "openhands/envs/feature/secrets/github-app.yaml" "github_decrypted.yaml"
-decrypt_and_move "openhands/envs/staging/secrets/keycloak-realm.yaml" "keycloak_realm_decrypted.yaml"
-decrypt_and_move "openhands/envs/staging/secrets/keycloak-admin.yaml" "keycloak_admin_decrypted.yaml"

enterprise/experiments/constants.py

@@ -1,47 +0,0 @@
-import os
-
-import posthog
-
-from openhands.core.logger import openhands_logger as logger
-
-# Initialize PostHog
-posthog.api_key = os.environ.get('POSTHOG_CLIENT_KEY', 'phc_placeholder')
-posthog.host = os.environ.get('POSTHOG_HOST', 'https://us.i.posthog.com')
-
-# Log PostHog configuration with masked API key for security
-api_key = posthog.api_key
-if api_key and len(api_key) > 8:
-    masked_key = f'{api_key[:4]}...{api_key[-4:]}'
-else:
-    masked_key = 'not_set_or_too_short'
-logger.info('posthog_configuration', extra={'posthog_api_key_masked': masked_key})
-
-# Global toggle for the experiment manager
-ENABLE_EXPERIMENT_MANAGER = (
-    os.environ.get('ENABLE_EXPERIMENT_MANAGER', 'false').lower() == 'true'
-)
-
-# Get the current experiment type from environment variable
-# If None, no experiment is running
-EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT = os.environ.get(
-    'EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT', ''
-)
-# System prompt experiment toggle
-EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT = os.environ.get(
-    'EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT', ''
-)
-
-EXPERIMENT_CLAUDE4_VS_GPT5 = os.environ.get('EXPERIMENT_CLAUDE4_VS_GPT5', '')
-
-EXPERIMENT_CONDENSER_MAX_STEP = os.environ.get('EXPERIMENT_CONDENSER_MAX_STEP', '')
-
-logger.info(
-    'experiment_manager:run_conversation_variant_test:experiment_config',
-    extra={
-        'enable_experiment_manager': ENABLE_EXPERIMENT_MANAGER,
-        'experiment_litellm_default_model_experiment': EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT,
-        'experiment_system_prompt_experiment': EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT,
-        'experiment_claude4_vs_gpt5_experiment': EXPERIMENT_CLAUDE4_VS_GPT5,
-        'experiment_condenser_max_step': EXPERIMENT_CONDENSER_MAX_STEP,
-    },
-)

enterprise/experiments/experiment_manager.py

@@ -1,97 +0,0 @@
-from uuid import UUID
-
-from experiments.constants import (
-    ENABLE_EXPERIMENT_MANAGER,
-    EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT,
-)
-from experiments.experiment_versions import (
-    handle_system_prompt_experiment,
-)
-
-from openhands.core.config.openhands_config import OpenHandsConfig
-from openhands.core.logger import openhands_logger as logger
-from openhands.experiments.experiment_manager import ExperimentManager
-from openhands.sdk import Agent
-from openhands.server.session.conversation_init_data import ConversationInitData
-
-
-class SaaSExperimentManager(ExperimentManager):
-    @staticmethod
-    def run_agent_variant_tests__v1(
-        user_id: str | None, conversation_id: UUID, agent: Agent
-    ) -> Agent:
-        if not ENABLE_EXPERIMENT_MANAGER:
-            logger.info(
-                'experiment_manager:run_conversation_variant_test:skipped',
-                extra={'reason': 'experiment_manager_disabled'},
-            )
-            return agent
-
-        if EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT:
-            agent = agent.model_copy(
-                update={'system_prompt_filename': 'system_prompt_long_horizon.j2'}
-            )
-
-        return agent
-
-    @staticmethod
-    def run_conversation_variant_test(
-        user_id, conversation_id, conversation_settings
-    ) -> ConversationInitData:
-        """
-        Run conversation variant test and potentially modify the conversation settings
-        based on the PostHog feature flags.
-
-        Args:
-            user_id: The user ID
-            conversation_id: The conversation ID
-            conversation_settings: The conversation settings that may include convo_id and llm_model
-
-        Returns:
-            The modified conversation settings
-        """
-        logger.debug(
-            'experiment_manager:run_conversation_variant_test:started',
-            extra={'user_id': user_id, 'conversation_id': conversation_id},
-        )
-
-        return conversation_settings
-
-    @staticmethod
-    def run_config_variant_test(
-        user_id: str | None, conversation_id: str, config: OpenHandsConfig
-    ) -> OpenHandsConfig:
-        """
-        Run agent config variant test and potentially modify the OpenHands config
-        based on the current experiment type and PostHog feature flags.
-
-        Args:
-            user_id: The user ID
-            conversation_id: The conversation ID
-            config: The OpenHands configuration
-
-        Returns:
-            The modified OpenHands configuration
-        """
-        logger.info(
-            'experiment_manager:run_config_variant_test:started',
-            extra={'user_id': user_id},
-        )
-
-        # Skip all experiment processing if the experiment manager is disabled
-        if not ENABLE_EXPERIMENT_MANAGER:
-            logger.info(
-                'experiment_manager:run_config_variant_test:skipped',
-                extra={'reason': 'experiment_manager_disabled'},
-            )
-            return config
-
-        # Pass the entire OpenHands config to the system prompt experiment
-        # Let the experiment handler directly modify the config as needed
-        modified_config = handle_system_prompt_experiment(
-            user_id, conversation_id, config
-        )
-
-        # Condenser max step experiment is applied via conversation variant test,
-        # not config variant test. Return modified config from system prompt only.
-        return modified_config

enterprise/experiments/experiment_versions/_001_litellm_default_model_experiment.py

@@ -1,107 +0,0 @@
-"""
-LiteLLM model experiment handler.
-
-This module contains the handler for the LiteLLM model experiment.
-"""
-
-import posthog
-from experiments.constants import EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT
-from server.constants import (
-    IS_FEATURE_ENV,
-    build_litellm_proxy_model_path,
-    get_default_litellm_model,
-)
-
-from openhands.core.logger import openhands_logger as logger
-
-
-def handle_litellm_default_model_experiment(
-    user_id, conversation_id, conversation_settings
-):
-    """
-    Handle the LiteLLM model experiment.
-
-    Args:
-        user_id: The user ID
-        conversation_id: The conversation ID
-        conversation_settings: The conversation settings
-
-    Returns:
-        Modified conversation settings
-    """
-    # No-op if the specific experiment is not enabled
-    if not EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT:
-        logger.info(
-            'experiment_manager:ab_testing:skipped',
-            extra={
-                'convo_id': conversation_id,
-                'reason': 'experiment_not_enabled',
-                'experiment': EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT,
-            },
-        )
-        return conversation_settings
-
-    # Use experiment name as the flag key
-    try:
-        enabled_variant = posthog.get_feature_flag(
-            EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT, conversation_id
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:get_feature_flag:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT,
-                'error': str(e),
-            },
-        )
-        return conversation_settings
-
-    # Log the experiment event
-    # If this is a feature environment, add "FEATURE_" prefix to user_id for PostHog
-    posthog_user_id = f'FEATURE_{user_id}' if IS_FEATURE_ENV else user_id
-
-    try:
-        posthog.capture(
-            distinct_id=posthog_user_id,
-            event='model_set',
-            properties={
-                'conversation_id': conversation_id,
-                'variant': enabled_variant,
-                'original_user_id': user_id,
-                'is_feature_env': IS_FEATURE_ENV,
-            },
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:posthog_capture:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_LITELLM_DEFAULT_MODEL_EXPERIMENT,
-                'error': str(e),
-            },
-        )
-        # Continue execution as this is not critical
-
-    logger.info(
-        'posthog_capture',
-        extra={
-            'event': 'model_set',
-            'posthog_user_id': posthog_user_id,
-            'is_feature_env': IS_FEATURE_ENV,
-            'conversation_id': conversation_id,
-            'variant': enabled_variant,
-        },
-    )
-
-    # Set the model based on the feature flag variant
-    if enabled_variant == 'claude37':
-        # Use the shared utility to construct the LiteLLM proxy model path
-        model = build_litellm_proxy_model_path('claude-3-7-sonnet-20250219')
-        # Update the conversation settings with the selected model
-        conversation_settings.llm_model = model
-    else:
-        # Update the conversation settings with the default model for the current version
-        conversation_settings.llm_model = get_default_litellm_model()
-
-    return conversation_settings

enterprise/experiments/experiment_versions/_002_system_prompt_experiment.py

@@ -1,181 +0,0 @@
-"""
-System prompt experiment handler.
-
-This module contains the handler for the system prompt experiment that uses
-the PostHog variant as the system prompt filename.
-"""
-
-import copy
-
-import posthog
-from experiments.constants import EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT
-from server.constants import IS_FEATURE_ENV
-from storage.experiment_assignment_store import ExperimentAssignmentStore
-
-from openhands.core.config.openhands_config import OpenHandsConfig
-from openhands.core.logger import openhands_logger as logger
-
-
-def _get_system_prompt_variant(user_id, conversation_id):
-    """
-    Get the system prompt variant for the experiment.
-
-    Args:
-        user_id: The user ID
-        conversation_id: The conversation ID
-
-    Returns:
-        str or None: The PostHog variant name or None if experiment is not enabled or error occurs
-    """
-    # No-op if the specific experiment is not enabled
-    if not EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT:
-        logger.info(
-            'experiment_manager_002:ab_testing:skipped',
-            extra={
-                'convo_id': conversation_id,
-                'reason': 'experiment_not_enabled',
-                'experiment': EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT,
-            },
-        )
-        return None
-
-    # Use experiment name as the flag key
-    try:
-        enabled_variant = posthog.get_feature_flag(
-            EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT, conversation_id
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:get_feature_flag:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT,
-                'error': str(e),
-            },
-        )
-        return None
-
-    # Store the experiment assignment in the database
-    try:
-        experiment_store = ExperimentAssignmentStore()
-        experiment_store.update_experiment_variant(
-            conversation_id=conversation_id,
-            experiment_name='system_prompt_experiment',
-            variant=enabled_variant,
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:store_assignment:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT,
-                'variant': enabled_variant,
-                'error': str(e),
-            },
-        )
-        # Fail the experiment if we cannot track the splits - results would not be explainable
-        return None
-
-    # Log the experiment event
-    # If this is a feature environment, add "FEATURE_" prefix to user_id for PostHog
-    posthog_user_id = f'FEATURE_{user_id}' if IS_FEATURE_ENV else user_id
-
-    try:
-        posthog.capture(
-            distinct_id=posthog_user_id,
-            event='system_prompt_set',
-            properties={
-                'conversation_id': conversation_id,
-                'variant': enabled_variant,
-                'original_user_id': user_id,
-                'is_feature_env': IS_FEATURE_ENV,
-            },
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:posthog_capture:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_SYSTEM_PROMPT_EXPERIMENT,
-                'error': str(e),
-            },
-        )
-        # Continue execution as this is not critical
-
-    logger.info(
-        'posthog_capture',
-        extra={
-            'event': 'system_prompt_set',
-            'posthog_user_id': posthog_user_id,
-            'is_feature_env': IS_FEATURE_ENV,
-            'conversation_id': conversation_id,
-            'variant': enabled_variant,
-        },
-    )
-
-    return enabled_variant
-
-
-def handle_system_prompt_experiment(
-    user_id, conversation_id, config: OpenHandsConfig
-) -> OpenHandsConfig:
-    """
-    Handle the system prompt experiment for OpenHands config.
-
-    Args:
-        user_id: The user ID
-        conversation_id: The conversation ID
-        config: The OpenHands configuration
-
-    Returns:
-        Modified OpenHands configuration
-    """
-    enabled_variant = _get_system_prompt_variant(user_id, conversation_id)
-
-    # If variant is None, experiment is not enabled or there was an error
-    if enabled_variant is None:
-        return config
-
-    # Deep copy the config to avoid modifying the original
-    modified_config = copy.deepcopy(config)
-
-    # Set the system prompt filename based on the variant
-    if enabled_variant == 'control':
-        # Use the long-horizon system prompt for the control variant
-        agent_config = modified_config.get_agent_config(modified_config.default_agent)
-        agent_config.system_prompt_filename = 'system_prompt_long_horizon.j2'
-        agent_config.enable_plan_mode = True
-    elif enabled_variant == 'interactive':
-        modified_config.get_agent_config(
-            modified_config.default_agent
-        ).system_prompt_filename = 'system_prompt_interactive.j2'
-    elif enabled_variant == 'no_tools':
-        modified_config.get_agent_config(
-            modified_config.default_agent
-        ).system_prompt_filename = 'system_prompt.j2'
-    else:
-        logger.error(
-            'system_prompt_experiment:unknown_variant',
-            extra={
-                'user_id': user_id,
-                'convo_id': conversation_id,
-                'variant': enabled_variant,
-                'reason': 'no explicit mapping; returning original config',
-            },
-        )
-        return config
-
-    # Log which prompt is being used
-    logger.info(
-        'system_prompt_experiment:prompt_selected',
-        extra={
-            'user_id': user_id,
-            'convo_id': conversation_id,
-            'system_prompt_filename': modified_config.get_agent_config(
-                modified_config.default_agent
-            ).system_prompt_filename,
-            'variant': enabled_variant,
-        },
-    )
-
-    return modified_config

enterprise/experiments/experiment_versions/_003_llm_claude4_vs_gpt5_experiment.py

@@ -1,137 +0,0 @@
-"""
-LiteLLM model experiment handler.
-
-This module contains the handler for the LiteLLM model experiment.
-"""
-
-import posthog
-from experiments.constants import EXPERIMENT_CLAUDE4_VS_GPT5
-from server.constants import (
-    IS_FEATURE_ENV,
-    build_litellm_proxy_model_path,
-    get_default_litellm_model,
-)
-from storage.experiment_assignment_store import ExperimentAssignmentStore
-
-from openhands.core.logger import openhands_logger as logger
-from openhands.server.session.conversation_init_data import ConversationInitData
-
-
-def _get_model_variant(user_id: str | None, conversation_id: str) -> str | None:
-    if not EXPERIMENT_CLAUDE4_VS_GPT5:
-        logger.info(
-            'experiment_manager:ab_testing:skipped',
-            extra={
-                'convo_id': conversation_id,
-                'reason': 'experiment_not_enabled',
-                'experiment': EXPERIMENT_CLAUDE4_VS_GPT5,
-            },
-        )
-        return None
-
-    try:
-        enabled_variant = posthog.get_feature_flag(
-            EXPERIMENT_CLAUDE4_VS_GPT5, conversation_id
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:get_feature_flag:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_CLAUDE4_VS_GPT5,
-                'error': str(e),
-            },
-        )
-        return None
-
-    # Store the experiment assignment in the database
-    try:
-        experiment_store = ExperimentAssignmentStore()
-        experiment_store.update_experiment_variant(
-            conversation_id=conversation_id,
-            experiment_name='claude4_vs_gpt5_experiment',
-            variant=enabled_variant,
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:store_assignment:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_CLAUDE4_VS_GPT5,
-                'variant': enabled_variant,
-                'error': str(e),
-            },
-        )
-        # Fail the experiment if we cannot track the splits - results would not be explainable
-        return None
-
-    # Log the experiment event
-    # If this is a feature environment, add "FEATURE_" prefix to user_id for PostHog
-    posthog_user_id = f'FEATURE_{user_id}' if IS_FEATURE_ENV else user_id
-
-    try:
-        posthog.capture(
-            distinct_id=posthog_user_id,
-            event='claude4_or_gpt5_set',
-            properties={
-                'conversation_id': conversation_id,
-                'variant': enabled_variant,
-                'original_user_id': user_id,
-                'is_feature_env': IS_FEATURE_ENV,
-            },
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:posthog_capture:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_CLAUDE4_VS_GPT5,
-                'error': str(e),
-            },
-        )
-        # Continue execution as this is not critical
-
-    logger.info(
-        'posthog_capture',
-        extra={
-            'event': 'claude4_or_gpt5_set',
-            'posthog_user_id': posthog_user_id,
-            'is_feature_env': IS_FEATURE_ENV,
-            'conversation_id': conversation_id,
-            'variant': enabled_variant,
-        },
-    )
-
-    return enabled_variant
-
-
-def handle_claude4_vs_gpt5_experiment(
-    user_id: str | None,
-    conversation_id: str,
-    conversation_settings: ConversationInitData,
-) -> ConversationInitData:
-    """
-    Handle the LiteLLM model experiment.
-
-    Args:
-        user_id: The user ID
-        conversation_id: The conversation ID
-        conversation_settings: The conversation settings
-
-    Returns:
-        Modified conversation settings
-    """
-
-    enabled_variant = _get_model_variant(user_id, conversation_id)
-
-    if not enabled_variant:
-        return conversation_settings
-
-    # Set the model based on the feature flag variant
-    if enabled_variant == 'gpt5':
-        model = build_litellm_proxy_model_path('gpt-5-2025-08-07')
-        conversation_settings.llm_model = model
-    else:
-        conversation_settings.llm_model = get_default_litellm_model()
-
-    return conversation_settings

enterprise/experiments/experiment_versions/_004_condenser_max_step_experiment.py

@@ -1,232 +0,0 @@
-"""
-Condenser max step experiment handler.
-
-This module contains the handler for the condenser max step experiment that tests
-different max_size values for the condenser configuration.
-"""
-
-from uuid import UUID
-
-import posthog
-from experiments.constants import EXPERIMENT_CONDENSER_MAX_STEP
-from server.constants import IS_FEATURE_ENV
-from storage.experiment_assignment_store import ExperimentAssignmentStore
-
-from openhands.core.logger import openhands_logger as logger
-from openhands.sdk import Agent
-from openhands.sdk.context.condenser import (
-    LLMSummarizingCondenser,
-)
-from openhands.server.session.conversation_init_data import ConversationInitData
-
-
-def _get_condenser_max_step_variant(user_id, conversation_id):
-    """
-    Get the condenser max step variant for the experiment.
-
-    Args:
-        user_id: The user ID
-        conversation_id: The conversation ID
-
-    Returns:
-        str or None: The PostHog variant name or None if experiment is not enabled or error occurs
-    """
-    # No-op if the specific experiment is not enabled
-    if not EXPERIMENT_CONDENSER_MAX_STEP:
-        logger.info(
-            'experiment_manager_004:ab_testing:skipped',
-            extra={
-                'convo_id': conversation_id,
-                'reason': 'experiment_not_enabled',
-                'experiment': EXPERIMENT_CONDENSER_MAX_STEP,
-            },
-        )
-        return None
-
-    # Use experiment name as the flag key
-    try:
-        enabled_variant = posthog.get_feature_flag(
-            EXPERIMENT_CONDENSER_MAX_STEP, conversation_id
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:get_feature_flag:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_CONDENSER_MAX_STEP,
-                'error': str(e),
-            },
-        )
-        return None
-
-    # Store the experiment assignment in the database
-    try:
-        experiment_store = ExperimentAssignmentStore()
-        experiment_store.update_experiment_variant(
-            conversation_id=conversation_id,
-            experiment_name='condenser_max_step_experiment',
-            variant=enabled_variant,
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:store_assignment:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_CONDENSER_MAX_STEP,
-                'variant': enabled_variant,
-                'error': str(e),
-            },
-        )
-        # Fail the experiment if we cannot track the splits - results would not be explainable
-        return None
-
-    # Log the experiment event
-    # If this is a feature environment, add "FEATURE_" prefix to user_id for PostHog
-    posthog_user_id = f'FEATURE_{user_id}' if IS_FEATURE_ENV else user_id
-
-    try:
-        posthog.capture(
-            distinct_id=posthog_user_id,
-            event='condenser_max_step_set',
-            properties={
-                'conversation_id': conversation_id,
-                'variant': enabled_variant,
-                'original_user_id': user_id,
-                'is_feature_env': IS_FEATURE_ENV,
-            },
-        )
-    except Exception as e:
-        logger.error(
-            'experiment_manager:posthog_capture:failed',
-            extra={
-                'convo_id': conversation_id,
-                'experiment': EXPERIMENT_CONDENSER_MAX_STEP,
-                'error': str(e),
-            },
-        )
-        # Continue execution as this is not critical
-
-    logger.info(
-        'posthog_capture',
-        extra={
-            'event': 'condenser_max_step_set',
-            'posthog_user_id': posthog_user_id,
-            'is_feature_env': IS_FEATURE_ENV,
-            'conversation_id': conversation_id,
-            'variant': enabled_variant,
-        },
-    )
-
-    return enabled_variant
-
-
-def handle_condenser_max_step_experiment(
-    user_id: str | None,
-    conversation_id: str,
-    conversation_settings: ConversationInitData,
-) -> ConversationInitData:
-    """
-    Handle the condenser max step experiment for conversation settings.
-
-    We should not modify persistent user settings. Instead, apply the experiment
-    variant to the conversation's in-memory settings object for this session only.
-
-    Variants:
-    - control -> condenser_max_size = 120
-    - treatment -> condenser_max_size = 80
-
-    Returns the (potentially) modified conversation_settings.
-    """
-
-    enabled_variant = _get_condenser_max_step_variant(user_id, conversation_id)
-
-    if enabled_variant is None:
-        return conversation_settings
-
-    if enabled_variant == 'control':
-        condenser_max_size = 120
-    elif enabled_variant == 'treatment':
-        condenser_max_size = 80
-    else:
-        logger.error(
-            'condenser_max_step_experiment:unknown_variant',
-            extra={
-                'user_id': user_id,
-                'convo_id': conversation_id,
-                'variant': enabled_variant,
-                'reason': 'unknown variant; returning original conversation settings',
-            },
-        )
-        return conversation_settings
-
-    try:
-        # Apply the variant to this conversation only; do not persist to DB.
-        # Not all OpenHands versions expose `condenser_max_size` on settings.
-        if hasattr(conversation_settings, 'condenser_max_size'):
-            conversation_settings.condenser_max_size = condenser_max_size
-            logger.info(
-                'condenser_max_step_experiment:conversation_settings_applied',
-                extra={
-                    'user_id': user_id,
-                    'convo_id': conversation_id,
-                    'variant': enabled_variant,
-                    'condenser_max_size': condenser_max_size,
-                },
-            )
-        else:
-            logger.warning(
-                'condenser_max_step_experiment:field_missing_on_settings',
-                extra={
-                    'user_id': user_id,
-                    'convo_id': conversation_id,
-                    'variant': enabled_variant,
-                    'reason': 'condenser_max_size not present on ConversationInitData',
-                },
-            )
-    except Exception as e:
-        logger.error(
-            'condenser_max_step_experiment:apply_failed',
-            extra={
-                'user_id': user_id,
-                'convo_id': conversation_id,
-                'variant': enabled_variant,
-                'error': str(e),
-            },
-        )
-        return conversation_settings
-
-    return conversation_settings
-
-
-def handle_condenser_max_step_experiment__v1(
-    user_id: str | None,
-    conversation_id: UUID,
-    agent: Agent,
-) -> Agent:
-    enabled_variant = _get_condenser_max_step_variant(user_id, str(conversation_id))
-
-    if enabled_variant is None:
-        return agent
-
-    if enabled_variant == 'control':
-        condenser_max_size = 120
-    elif enabled_variant == 'treatment':
-        condenser_max_size = 80
-    else:
-        logger.error(
-            'condenser_max_step_experiment:unknown_variant',
-            extra={
-                'user_id': user_id,
-                'convo_id': conversation_id,
-                'variant': enabled_variant,
-                'reason': 'unknown variant; returning original conversation settings',
-            },
-        )
-        return agent
-
-    condenser_llm = agent.llm.model_copy(update={'usage_id': 'condenser'})
-    condenser = LLMSummarizingCondenser(
-        llm=condenser_llm, max_size=condenser_max_size, keep_first=4
-    )
-
-    return agent.model_copy(update={'condenser': condenser})

enterprise/experiments/experiment_versions/__init__.py

@@ -1,25 +0,0 @@
-"""
-Experiment versions package.
-
-This package contains handlers for different experiment versions.
-"""
-
-from experiments.experiment_versions._001_litellm_default_model_experiment import (
-    handle_litellm_default_model_experiment,
-)
-from experiments.experiment_versions._002_system_prompt_experiment import (
-    handle_system_prompt_experiment,
-)
-from experiments.experiment_versions._003_llm_claude4_vs_gpt5_experiment import (
-    handle_claude4_vs_gpt5_experiment,
-)
-from experiments.experiment_versions._004_condenser_max_step_experiment import (
-    handle_condenser_max_step_experiment,
-)
-
-__all__ = [
-    'handle_litellm_default_model_experiment',
-    'handle_system_prompt_experiment',
-    'handle_claude4_vs_gpt5_experiment',
-    'handle_condenser_max_step_experiment',
-]

enterprise/integrations/bitbucket/bitbucket_service.py

@@ -1,70 +0,0 @@
-from pydantic import SecretStr
-from server.auth.token_manager import TokenManager
-
-from openhands.core.logger import openhands_logger as logger
-from openhands.integrations.bitbucket.bitbucket_service import BitBucketService
-from openhands.integrations.service_types import ProviderType
-
-
-class SaaSBitBucketService(BitBucketService):
-    def __init__(
-        self,
-        user_id: str | None = None,
-        external_auth_token: SecretStr | None = None,
-        external_auth_id: str | None = None,
-        token: SecretStr | None = None,
-        external_token_manager: bool = False,
-        base_domain: str | None = None,
-    ):
-        logger.info(
-            f'SaaSBitBucketService created with user_id {user_id}, external_auth_id {external_auth_id}, external_auth_token {'set' if external_auth_token else 'None'}, bitbucket_token {'set' if token else 'None'}, external_token_manager {external_token_manager}'
-        )
-        super().__init__(
-            user_id=user_id,
-            external_auth_token=external_auth_token,
-            external_auth_id=external_auth_id,
-            token=token,
-            external_token_manager=external_token_manager,
-            base_domain=base_domain,
-        )
-
-        self.external_auth_token = external_auth_token
-        self.external_auth_id = external_auth_id
-        self.token_manager = TokenManager(external=external_token_manager)
-
-    async def get_latest_token(self) -> SecretStr | None:
-        bitbucket_token = None
-        if self.external_auth_token:
-            bitbucket_token = SecretStr(
-                await self.token_manager.get_idp_token(
-                    self.external_auth_token.get_secret_value(),
-                    idp=ProviderType.BITBUCKET,
-                )
-            )
-            logger.debug(
-                f'Got BitBucket token {bitbucket_token} from access token: {self.external_auth_token}'
-            )
-        elif self.external_auth_id:
-            offline_token = await self.token_manager.load_offline_token(
-                self.external_auth_id
-            )
-            bitbucket_token = SecretStr(
-                await self.token_manager.get_idp_token_from_offline_token(
-                    offline_token, ProviderType.BITBUCKET
-                )
-            )
-            logger.info(
-                f'Got BitBucket token {bitbucket_token.get_secret_value()} from external auth user ID: {self.external_auth_id}'
-            )
-        elif self.user_id:
-            bitbucket_token = SecretStr(
-                await self.token_manager.get_idp_token_from_idp_user_id(
-                    self.user_id, ProviderType.BITBUCKET
-                )
-            )
-            logger.debug(
-                f'Got BitBucket token {bitbucket_token} from user ID: {self.user_id}'
-            )
-        else:
-            logger.warning('external_auth_token and user_id not set!')
-        return bitbucket_token

enterprise/integrations/github/data_collector.py

@@ -1,692 +0,0 @@
-import base64
-import json
-import os
-import re
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-from github import Auth, Github, GithubIntegration
-from integrations.github.github_view import (
-    GithubIssue,
-)
-from integrations.github.queries import PR_QUERY_BY_NODE_ID
-from integrations.models import Message
-from integrations.types import PRStatus, ResolverViewInterface
-from integrations.utils import HOST
-from pydantic import SecretStr
-from server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY
-from storage.openhands_pr import OpenhandsPR
-from storage.openhands_pr_store import OpenhandsPRStore
-
-from openhands.core.config import load_openhands_config
-from openhands.core.logger import openhands_logger as logger
-from openhands.integrations.github.github_service import GithubServiceImpl
-from openhands.integrations.service_types import ProviderType
-from openhands.storage import get_file_store
-from openhands.storage.locations import get_conversation_dir
-
-config = load_openhands_config()
-file_store = get_file_store(config.file_store, config.file_store_path)
-
-
-COLLECT_GITHUB_INTERACTIONS = (
-    os.getenv('COLLECT_GITHUB_INTERACTIONS', 'false') == 'true'
-)
-
-
-class TriggerType(str, Enum):
-    ISSUE_LABEL = 'issue-label'
-    ISSUE_COMMENT = 'issue-coment'
-    PR_COMMENT_MACRO = 'label'
-    INLINE_PR_COMMENT_MACRO = 'inline-label'
-
-
-class GitHubDataCollector:
-    """
-    Saves data on Cloud Resolver Interactions
-
-    1. We always save
-        - Resolver trigger (comment or label)
-        - Metadata (who started the job, repo name, issue number)
-
-    2. We save data for the type of interaction
-        a. For labelled issues, we save
-            - {conversation_dir}/{conversation_id}/github_data/issue__{repo_name}_{issue_number}.json
-                - issue number
-                - trigger
-                - metadata
-                - body
-                - title
-                - comments
-
-            - {conversation_dir}/{conversation_id}/github_data/pr__{repo_name}_{pr_number}.json
-                - pr_number
-                - metadata
-                - body
-                - title
-                - commits/authors
-
-    3. For all PRs that were opened with the resolver, we save
-        - github_data/prs/{repo_name}_{pr_number}/data.json
-            - pr_number
-            - title
-            - body
-            - commits/authors
-            - code diffs
-            - merge status (either merged/closed)
-    """
-
-    def __init__(self):
-        self.file_store = file_store
-        self.issues_path = 'github_data/issue-{}-{}/data.json'
-        self.matching_pr_path = 'github_data/pr-{}-{}/data.json'
-        # self.full_saved_pr_path = 'github_data/prs/{}-{}/data.json'
-        self.full_saved_pr_path = 'prs/github/{}-{}/data.json'
-        self.github_integration = GithubIntegration(
-            auth=Auth.AppAuth(GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY)
-        )
-        self.conversation_id = None
-
-    async def _get_repo_node_id(self, repo_id: str, gh_client) -> str:
-        """
-        Get the new GitHub GraphQL node ID for a repository using the GitHub client.
-
-        Args:
-            repo_id: Numeric repository ID as string (e.g., "123456789")
-            gh_client: SaaSGitHubService client with authentication
-
-        Returns:
-            New format node ID for GraphQL queries (e.g., "R_kgDOLfkiww")
-        """
-        try:
-            return await gh_client.get_repository_node_id(repo_id)
-        except Exception:
-            # Fallback to old format if REST API fails
-            node_string = f'010:Repository{repo_id}'
-            return base64.b64encode(node_string.encode()).decode()
-
-    def _create_file_name(
-        self, path: str, repo_id: str, number: int, conversation_id: str | None
-    ):
-        suffix = path.format(repo_id, number)
-
-        if conversation_id:
-            return f'{get_conversation_dir(conversation_id)}{suffix}'
-
-        return suffix
-
-    def _get_installation_access_token(self, installation_id: str) -> str:
-        token_data = self.github_integration.get_access_token(
-            installation_id  # type: ignore[arg-type]
-        )
-        return token_data.token
-
-    def _check_openhands_author(self, name, login) -> bool:
-        return (
-            name == 'openhands'
-            or login == 'openhands'
-            or login == 'openhands-agent'
-            or login == 'openhands-ai'
-            or login == 'openhands-staging'
-            or login == 'openhands-exp'
-            or (login and 'openhands' in login.lower())
-        )
-
-    def _get_issue_comments(
-        self, installation_id: str, repo_name: str, issue_number: int, conversation_id
-    ) -> list[dict[str, Any]]:
-        """
-        Retrieve all comments from an issue until a comment with conversation_id is found
-        """
-
-        try:
-            installation_token = self._get_installation_access_token(installation_id)
-
-            with Github(auth=Auth.Token(installation_token)) as github_client:
-                repo = github_client.get_repo(repo_name)
-                issue = repo.get_issue(issue_number)
-                comments = []
-
-                for comment in issue.get_comments():
-                    comment_data = {
-                        'id': comment.id,
-                        'body': comment.body,
-                        'created_at': comment.created_at.isoformat(),
-                        'user': comment.user.login,
-                    }
-
-                    # If we find a comment containing conversation_id, stop collecting comments
-                    if conversation_id in comment.body:
-                        break
-
-                    comments.append(comment_data)
-
-                return comments
-        except Exception:
-            return []
-
-    def _save_data(self, path: str, data: dict[str, Any]):
-        """Save data to a path"""
-        self.file_store.write(path, json.dumps(data))
-
-    def _save_issue(
-        self,
-        github_view: GithubIssue,
-        trigger_type: TriggerType,
-    ) -> None:
-        """
-        Save issue data when it's labeled with openhands
-
-            1. Save under {conversation_dir}/{conversation_id}/github_data/issue_{issue_number}.json
-            2. Save issue snapshot (title, body, comments)
-            3. Save trigger type (label)
-            4. Save PR opened (if exists, this information comes later when agent has finished its task)
-                - Save commit shas
-                - Save author info
-            5. Was PR merged or closed
-        """
-
-        conversation_id = github_view.conversation_id
-
-        if not conversation_id:
-            return
-
-        issue_number = github_view.issue_number
-        file_name = self._create_file_name(
-            path=self.issues_path,
-            repo_id=github_view.full_repo_name,
-            number=issue_number,
-            conversation_id=conversation_id,
-        )
-
-        payload_data = github_view.raw_payload.message.get('payload', {})
-        isssue_details = payload_data.get('issue', {})
-        is_repo_private = payload_data.get('repository', {}).get('private', 'true')
-        title = isssue_details.get('title', '')
-        body = isssue_details.get('body', '')
-
-        # Get comments for the issue
-        comments = self._get_issue_comments(
-            github_view.installation_id,
-            github_view.full_repo_name,
-            issue_number,
-            conversation_id,
-        )
-
-        data = {
-            'trigger': trigger_type,
-            'metadata': {
-                'user': github_view.user_info.username,
-                'repo_name': github_view.full_repo_name,
-                'is_repo_private': is_repo_private,
-                'number': issue_number,
-            },
-            'contents': {
-                'title': title,
-                'body': body,
-                'comments': comments,
-            },
-        }
-
-        self._save_data(file_name, data)
-        logger.info(
-            f'[Github]: Saved issue #{issue_number} for {github_view.full_repo_name}'
-        )
-
-    def _get_pr_commits(self, installation_id: str, repo_name: str, pr_number: int):
-        commits = []
-        installation_token = self._get_installation_access_token(installation_id)
-        with Github(auth=Auth.Token(installation_token)) as github_client:
-            repo = github_client.get_repo(repo_name)
-            pr = repo.get_pull(pr_number)
-
-            for commit in pr.get_commits():
-                commit_data = {
-                    'sha': commit.sha,
-                    'authors': commit.author.login if commit.author else None,
-                    'committed_date': commit.commit.committer.date.isoformat()
-                    if commit.commit and commit.commit.committer
-                    else None,
-                }
-                commits.append(commit_data)
-
-        return commits
-
-    def _extract_repo_metadata(self, repo_data: dict) -> dict:
-        """Extract repository metadata from GraphQL response"""
-        return {
-            'name': repo_data.get('name'),
-            'owner': repo_data.get('owner', {}).get('login'),
-            'languages': [
-                lang['name'] for lang in repo_data.get('languages', {}).get('nodes', [])
-            ],
-        }
-
-    def _process_commits_page(self, pr_data: dict, commits: list) -> None:
-        """Process commits from a single GraphQL page"""
-        commit_nodes = pr_data.get('commits', {}).get('nodes', [])
-        for commit_node in commit_nodes:
-            commit = commit_node['commit']
-            author_info = commit.get('author', {})
-            commit_data = {
-                'sha': commit['oid'],
-                'message': commit['message'],
-                'committed_date': commit.get('committedDate'),
-                'author': {
-                    'name': author_info.get('name'),
-                    'email': author_info.get('email'),
-                    'github_login': author_info.get('user', {}).get('login'),
-                },
-                'stats': {
-                    'additions': commit.get('additions', 0),
-                    'deletions': commit.get('deletions', 0),
-                    'changed_files': commit.get('changedFiles', 0),
-                },
-            }
-            commits.append(commit_data)
-
-    def _process_pr_comments_page(self, pr_data: dict, pr_comments: list) -> None:
-        """Process PR comments from a single GraphQL page"""
-        comment_nodes = pr_data.get('comments', {}).get('nodes', [])
-        for comment in comment_nodes:
-            comment_data = {
-                'author': comment.get('author', {}).get('login'),
-                'body': comment.get('body'),
-                'created_at': comment.get('createdAt'),
-                'type': 'pr_comment',
-            }
-            pr_comments.append(comment_data)
-
-    def _process_review_comments_page(
-        self, pr_data: dict, review_comments: list
-    ) -> None:
-        """Process reviews and review comments from a single GraphQL page"""
-        review_nodes = pr_data.get('reviews', {}).get('nodes', [])
-        for review in review_nodes:
-            # Add the review itself if it has a body
-            if review.get('body', '').strip():
-                review_data = {
-                    'author': review.get('author', {}).get('login'),
-                    'body': review.get('body'),
-                    'created_at': review.get('createdAt'),
-                    'state': review.get('state'),
-                    'type': 'review',
-                }
-                review_comments.append(review_data)
-
-            # Add individual review comments
-            review_comment_nodes = review.get('comments', {}).get('nodes', [])
-            for review_comment in review_comment_nodes:
-                review_comment_data = {
-                    'author': review_comment.get('author', {}).get('login'),
-                    'body': review_comment.get('body'),
-                    'created_at': review_comment.get('createdAt'),
-                    'type': 'review_comment',
-                }
-                review_comments.append(review_comment_data)
-
-    def _count_openhands_activity(
-        self, commits: list, review_comments: list, pr_comments: list
-    ) -> tuple[int, int, int]:
-        """Count OpenHands commits, review comments, and general PR comments"""
-        openhands_commit_count = 0
-        openhands_review_comment_count = 0
-        openhands_general_comment_count = 0
-
-        # Count commits by OpenHands (check both name and login)
-        for commit in commits:
-            author = commit.get('author', {})
-            author_name = author.get('name', '').lower()
-            author_login = (
-                author.get('github_login', '').lower()
-                if author.get('github_login')
-                else ''
-            )
-
-            if self._check_openhands_author(author_name, author_login):
-                openhands_commit_count += 1
-
-        # Count review comments by OpenHands
-        for review_comment in review_comments:
-            author_login = (
-                review_comment.get('author', '').lower()
-                if review_comment.get('author')
-                else ''
-            )
-            author_name = ''  # Initialize to avoid reference before assignment
-            if self._check_openhands_author(author_name, author_login):
-                openhands_review_comment_count += 1
-
-        # Count general PR comments by OpenHands
-        for pr_comment in pr_comments:
-            author_login = (
-                pr_comment.get('author', '').lower() if pr_comment.get('author') else ''
-            )
-            author_name = ''  # Initialize to avoid reference before assignment
-            if self._check_openhands_author(author_name, author_login):
-                openhands_general_comment_count += 1
-
-        return (
-            openhands_commit_count,
-            openhands_review_comment_count,
-            openhands_general_comment_count,
-        )
-
-    def _build_final_data_structure(
-        self,
-        repo_data: dict,
-        pr_data: dict,
-        commits: list,
-        pr_comments: list,
-        review_comments: list,
-        openhands_commit_count: int,
-        openhands_review_comment_count: int,
-        openhands_general_comment_count: int = 0,
-    ) -> dict:
-        """Build the final data structure for JSON storage"""
-
-        is_merged = pr_data['merged']
-        merged_by = None
-        merge_commit_sha = None
-        if is_merged:
-            merged_by = (pr_data.get('mergedBy') or {}).get('login')
-            merge_commit_sha = (pr_data.get('mergeCommit') or {}).get('oid')
-
-        return {
-            'repo_metadata': self._extract_repo_metadata(repo_data),
-            'pr_metadata': {
-                'username': (pr_data.get('author') or {}).get('login'),
-                'number': pr_data.get('number'),
-                'title': pr_data.get('title'),
-                'body': pr_data.get('body'),
-                'comments': pr_comments,
-            },
-            'commits': commits,
-            'review_comments': review_comments,
-            'merge_status': {
-                'merged': pr_data.get('merged'),
-                'merged_by': merged_by,
-                'state': pr_data.get('state'),
-                'merge_commit_sha': merge_commit_sha,
-            },
-            'openhands_stats': {
-                'num_commits': openhands_commit_count,
-                'num_review_comments': openhands_review_comment_count,
-                'num_general_comments': openhands_general_comment_count,
-                'helped_author': openhands_commit_count > 0,
-            },
-        }
-
-    async def save_full_pr(self, openhands_pr: OpenhandsPR) -> None:
-        """
-        Save PR information including metadata and commit details using GraphQL
-
-        Saves:
-        - Repo metadata (repo name, languages, contributors)
-        - PR metadata (number, title, body, author, comments)
-        - Commit information (sha, authors, message, stats)
-        - Merge status
-        - Num openhands commits
-        - Num openhands review comments
-        """
-        pr_number = openhands_pr.pr_number
-        installation_id = openhands_pr.installation_id
-        repo_id = openhands_pr.repo_id
-
-        # Get installation token and create Github client
-        # This will fail if the user decides to revoke OpenHands' access to their repo
-        # In this case, we will simply return when the exception occurs
-        # This will not lead to infinite loops when processing PRs as we log number of attempts and cap max attempts independently from this
-        try:
-            installation_token = self._get_installation_access_token(installation_id)
-        except Exception as e:
-            logger.warning(
-                f'Failed to generate token for {openhands_pr.repo_name}: {e}'
-            )
-            return
-
-        gh_client = GithubServiceImpl(token=SecretStr(installation_token))
-
-        # Get the new format GraphQL node ID
-        node_id = await self._get_repo_node_id(repo_id, gh_client)
-
-        # Initialize data structures
-        commits: list[dict] = []
-        pr_comments: list[dict] = []
-        review_comments: list[dict] = []
-        pr_data = None
-        repo_data = None
-
-        # Pagination cursors
-        commits_after = None
-        comments_after = None
-        reviews_after = None
-
-        # Fetch all data with pagination
-        while True:
-            variables = {
-                'nodeId': node_id,
-                'pr_number': pr_number,
-                'commits_after': commits_after,
-                'comments_after': comments_after,
-                'reviews_after': reviews_after,
-            }
-
-            try:
-                result = await gh_client.execute_graphql_query(
-                    PR_QUERY_BY_NODE_ID, variables
-                )
-                if not result.get('data', {}).get('node', {}).get('pullRequest'):
-                    break
-
-                pr_data = result['data']['node']['pullRequest']
-                repo_data = result['data']['node']
-
-                # Process data from this page using modular methods
-                self._process_commits_page(pr_data, commits)
-                self._process_pr_comments_page(pr_data, pr_comments)
-                self._process_review_comments_page(pr_data, review_comments)
-
-                # Check pagination for all three types
-                has_more_commits = (
-                    pr_data.get('commits', {})
-                    .get('pageInfo', {})
-                    .get('hasNextPage', False)
-                )
-                has_more_comments = (
-                    pr_data.get('comments', {})
-                    .get('pageInfo', {})
-                    .get('hasNextPage', False)
-                )
-                has_more_reviews = (
-                    pr_data.get('reviews', {})
-                    .get('pageInfo', {})
-                    .get('hasNextPage', False)
-                )
-
-                # Update cursors
-                if has_more_commits:
-                    commits_after = (
-                        pr_data.get('commits', {}).get('pageInfo', {}).get('endCursor')
-                    )
-                else:
-                    commits_after = None
-
-                if has_more_comments:
-                    comments_after = (
-                        pr_data.get('comments', {}).get('pageInfo', {}).get('endCursor')
-                    )
-                else:
-                    comments_after = None
-
-                if has_more_reviews:
-                    reviews_after = (
-                        pr_data.get('reviews', {}).get('pageInfo', {}).get('endCursor')
-                    )
-                else:
-                    reviews_after = None
-
-                # Continue if there's more data to fetch
-                if not (has_more_commits or has_more_comments or has_more_reviews):
-                    break
-
-            except Exception:
-                logger.warning('Error fetching PR data', exc_info=True)
-                return
-
-        if not pr_data or not repo_data:
-            return
-
-        # Count OpenHands activity using modular method
-        (
-            openhands_commit_count,
-            openhands_review_comment_count,
-            openhands_general_comment_count,
-        ) = self._count_openhands_activity(commits, review_comments, pr_comments)
-
-        logger.info(
-            f'[Github]: PR #{pr_number} - OpenHands commits: {openhands_commit_count}, review comments: {openhands_review_comment_count}, general comments: {openhands_general_comment_count}'
-        )
-        logger.info(
-            f'[Github]: PR #{pr_number} - Total collected: {len(commits)} commits, {len(pr_comments)} PR comments, {len(review_comments)} review comments'
-        )
-
-        # Build final data structure using modular method
-        data = self._build_final_data_structure(
-            repo_data,
-            pr_data or {},
-            commits,
-            pr_comments,
-            review_comments,
-            openhands_commit_count,
-            openhands_review_comment_count,
-            openhands_general_comment_count,
-        )
-
-        # Update the OpenhandsPR object with OpenHands statistics
-        store = OpenhandsPRStore.get_instance()
-        openhands_helped_author = openhands_commit_count > 0
-
-        # Update the PR with OpenHands statistics
-        update_success = store.update_pr_openhands_stats(
-            repo_id=repo_id,
-            pr_number=pr_number,
-            original_updated_at=openhands_pr.updated_at,
-            openhands_helped_author=openhands_helped_author,
-            num_openhands_commits=openhands_commit_count,
-            num_openhands_review_comments=openhands_review_comment_count,
-            num_openhands_general_comments=openhands_general_comment_count,
-        )
-
-        if not update_success:
-            logger.warning(
-                f'[Github]: Failed to update OpenHands stats for PR #{pr_number} in repo {repo_id} - PR may have been modified concurrently'
-            )
-
-        # Save to file
-        file_name = self._create_file_name(
-            path=self.full_saved_pr_path,
-            repo_id=repo_id,
-            number=pr_number,
-            conversation_id=None,
-        )
-        self._save_data(file_name, data)
-        logger.info(
-            f'[Github]: Saved full PR #{pr_number} for repo {repo_id} with OpenHands stats: commits={openhands_commit_count}, reviews={openhands_review_comment_count}, general_comments={openhands_general_comment_count}, helped={openhands_helped_author}'
-        )
-
-    def _check_for_conversation_url(self, body):
-        conversation_pattern = re.search(
-            rf'https://{HOST}/conversations/([a-zA-Z0-9-]+)(?:\s|[.,;!?)]|$)', body
-        )
-        if conversation_pattern:
-            return conversation_pattern.group(1)
-
-        return None
-
-    def _is_pr_closed_or_merged(self, payload):
-        """
-        Check if PR was closed (regardless of conversation URL)
-        """
-        action = payload.get('action', '')
-        return action == 'closed' and 'pull_request' in payload
-
-    def _track_closed_or_merged_pr(self, payload):
-        """
-        Track PR closed/merged event
-        """
-
-        repo_id = str(payload['repository']['id'])
-        pr_number = payload['number']
-        installation_id = str(payload['installation']['id'])
-        private = payload['repository']['private']
-        repo_name = payload['repository']['full_name']
-
-        pr_data = payload['pull_request']
-
-        # Extract PR metrics
-        num_reviewers = len(pr_data.get('requested_reviewers', []))
-        num_commits = pr_data.get('commits', 0)
-        num_review_comments = pr_data.get('review_comments', 0)
-        num_general_comments = pr_data.get('comments', 0)
-        num_changed_files = pr_data.get('changed_files', 0)
-        num_additions = pr_data.get('additions', 0)
-        num_deletions = pr_data.get('deletions', 0)
-        merged = pr_data.get('merged', False)
-
-        # Extract closed_at timestamp
-        # Example: "closed_at":"2025-06-19T21:19:36Z"
-        closed_at_str = pr_data.get('closed_at')
-        created_at = pr_data.get('created_at')
-
-        closed_at = datetime.fromisoformat(closed_at_str.replace('Z', '+00:00'))
-
-        # Determine status based on whether it was merged
-        status = PRStatus.MERGED if merged else PRStatus.CLOSED
-
-        store = OpenhandsPRStore.get_instance()
-
-        pr = OpenhandsPR(
-            repo_name=repo_name,
-            repo_id=repo_id,
-            pr_number=pr_number,
-            status=status,
-            provider=ProviderType.GITHUB.value,
-            installation_id=installation_id,
-            private=private,
-            num_reviewers=num_reviewers,
-            num_commits=num_commits,
-            num_review_comments=num_review_comments,
-            num_changed_files=num_changed_files,
-            num_additions=num_additions,
-            num_deletions=num_deletions,
-            merged=merged,
-            created_at=created_at,
-            closed_at=closed_at,
-            # These properties will be enriched later
-            openhands_helped_author=None,
-            num_openhands_commits=None,
-            num_openhands_review_comments=None,
-            num_general_comments=num_general_comments,
-        )
-
-        store.insert_pr(pr)
-        logger.info(f'Tracked PR {status}: {repo_id}#{pr_number}')
-
-    def process_payload(self, message: Message):
-        if not COLLECT_GITHUB_INTERACTIONS:
-            return
-
-        raw_payload = message.message.get('payload', {})
-
-        if self._is_pr_closed_or_merged(raw_payload):
-            self._track_closed_or_merged_pr(raw_payload)
-
-    async def save_data(self, github_view: ResolverViewInterface):
-        if not COLLECT_GITHUB_INTERACTIONS:
-            return
-
-        return
-
-        # TODO: track issue metadata in DB and save comments to filestore

enterprise/integrations/github/github_manager.py

@@ -1,372 +0,0 @@
-from types import MappingProxyType
-
-from github import Auth, Github, GithubIntegration
-from integrations.github.data_collector import GitHubDataCollector
-from integrations.github.github_solvability import summarize_issue_solvability
-from integrations.github.github_view import (
-    GithubFactory,
-    GithubFailingAction,
-    GithubInlinePRComment,
-    GithubIssue,
-    GithubIssueComment,
-    GithubPRComment,
-)
-from integrations.manager import Manager
-from integrations.models import (
-    Message,
-    SourceType,
-)
-from integrations.types import ResolverViewInterface
-from integrations.utils import (
-    CONVERSATION_URL,
-    HOST_URL,
-    OPENHANDS_RESOLVER_TEMPLATES_DIR,
-    get_session_expired_message,
-)
-from integrations.v1_utils import get_saas_user_auth
-from jinja2 import Environment, FileSystemLoader
-from pydantic import SecretStr
-from server.auth.auth_error import ExpiredError
-from server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY
-from server.auth.token_manager import TokenManager
-from server.utils.conversation_callback_utils import register_callback_processor
-
-from openhands.core.logger import openhands_logger as logger
-from openhands.integrations.provider import ProviderToken, ProviderType
-from openhands.integrations.service_types import AuthenticationError
-from openhands.server.types import (
-    LLMAuthenticationError,
-    MissingSettingsError,
-    SessionExpiredError,
-)
-from openhands.storage.data_models.secrets import Secrets
-from openhands.utils.async_utils import call_sync_from_async
-
-
-class GithubManager(Manager):
-    def __init__(
-        self, token_manager: TokenManager, data_collector: GitHubDataCollector
-    ):
-        self.token_manager = token_manager
-        self.data_collector = data_collector
-        self.github_integration = GithubIntegration(
-            auth=Auth.AppAuth(GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY)
-        )
-
-        self.jinja_env = Environment(
-            loader=FileSystemLoader(OPENHANDS_RESOLVER_TEMPLATES_DIR + 'github')
-        )
-
-    def _confirm_incoming_source_type(self, message: Message):
-        if message.source != SourceType.GITHUB:
-            raise ValueError(f'Unexpected message source {message.source}')
-
-    def _get_full_repo_name(self, repo_obj: dict) -> str:
-        owner = repo_obj['owner']['login']
-        repo_name = repo_obj['name']
-
-        return f'{owner}/{repo_name}'
-
-    def _get_installation_access_token(self, installation_id: str) -> str:
-        # get_access_token is typed to only accept int, but it can handle str.
-        token_data = self.github_integration.get_access_token(
-            installation_id  # type: ignore[arg-type]
-        )
-        return token_data.token
-
-    def _add_reaction(
-        self, github_view: ResolverViewInterface, reaction: str, installation_token: str
-    ):
-        """Add a reaction to the GitHub issue, PR, or comment.
-
-        Args:
-            github_view: The GitHub view object containing issue/PR/comment info
-            reaction: The reaction to add (e.g. "eyes", "+1", "-1", "laugh", "confused", "heart", "hooray", "rocket")
-            installation_token: GitHub installation access token for API access
-        """
-        with Github(auth=Auth.Token(installation_token)) as github_client:
-            repo = github_client.get_repo(github_view.full_repo_name)
-            # Add reaction based on view type
-            if isinstance(github_view, GithubInlinePRComment):
-                pr = repo.get_pull(github_view.issue_number)
-                inline_comment = pr.get_review_comment(github_view.comment_id)
-                inline_comment.create_reaction(reaction)
-
-            elif isinstance(github_view, (GithubIssueComment, GithubPRComment)):
-                issue = repo.get_issue(github_view.issue_number)
-                comment = issue.get_comment(github_view.comment_id)
-                comment.create_reaction(reaction)
-            else:
-                issue = repo.get_issue(github_view.issue_number)
-                issue.create_reaction(reaction)
-
-    def _user_has_write_access_to_repo(
-        self, installation_id: str, full_repo_name: str, username: str
-    ) -> bool:
-        """Check if the user is an owner, collaborator, or member of the repository."""
-        with self.github_integration.get_github_for_installation(
-            installation_id,  # type: ignore[arg-type]
-            {},
-        ) as repos:
-            repository = repos.get_repo(full_repo_name)
-
-            # Check if the user is a collaborator
-            try:
-                collaborator = repository.get_collaborator_permission(username)
-                if collaborator in ['admin', 'write']:
-                    return True
-            except Exception:
-                pass
-
-            # If the above fails, check if the user is an owner or member
-            org = repository.organization
-            if org:
-                user = org.get_members(username)
-                return user is not None
-
-            return False
-
-    async def is_job_requested(self, message: Message) -> bool:
-        self._confirm_incoming_source_type(message)
-
-        installation_id = message.message['installation']
-        payload = message.message.get('payload', {})
-        repo_obj = payload.get('repository')
-        if not repo_obj:
-            return False
-        username = payload.get('sender', {}).get('login')
-        repo_name = self._get_full_repo_name(repo_obj)
-
-        # Suggestions contain `@openhands` macro; avoid kicking off jobs for system recommendations
-        if GithubFactory.is_pr_comment(
-            message
-        ) and GithubFailingAction.unqiue_suggestions_header in payload.get(
-            'comment', {}
-        ).get('body', ''):
-            return False
-
-        if GithubFactory.is_eligible_for_conversation_starter(
-            message
-        ) and self._user_has_write_access_to_repo(installation_id, repo_name, username):
-            await GithubFactory.trigger_conversation_starter(message)
-
-        if not (
-            GithubFactory.is_labeled_issue(message)
-            or GithubFactory.is_issue_comment(message)
-            or GithubFactory.is_pr_comment(message)
-            or GithubFactory.is_inline_pr_comment(message)
-        ):
-            return False
-
-        logger.info(f'[GitHub] Checking permissions for {username} in {repo_name}')
-
-        return self._user_has_write_access_to_repo(installation_id, repo_name, username)
-
-    async def receive_message(self, message: Message):
-        self._confirm_incoming_source_type(message)
-        try:
-            await call_sync_from_async(self.data_collector.process_payload, message)
-        except Exception:
-            logger.warning(
-                '[Github]: Error processing payload for gh interaction', exc_info=True
-            )
-
-        if await self.is_job_requested(message):
-            payload = message.message.get('payload', {})
-            user_id = payload['sender']['id']
-            keycloak_user_id = await self.token_manager.get_user_id_from_idp_user_id(
-                user_id, ProviderType.GITHUB
-            )
-            github_view = await GithubFactory.create_github_view_from_payload(
-                message, keycloak_user_id
-            )
-            logger.info(
-                f'[GitHub] Creating job for {github_view.user_info.username} in {github_view.full_repo_name}#{github_view.issue_number}'
-            )
-            # Get the installation token
-            installation_token = self._get_installation_access_token(
-                github_view.installation_id
-            )
-            # Store the installation token
-            self.token_manager.store_org_token(
-                github_view.installation_id, installation_token
-            )
-            # Add eyes reaction to acknowledge we've read the request
-            self._add_reaction(github_view, 'eyes', installation_token)
-            await self.start_job(github_view)
-
-    async def send_message(self, message: Message, github_view: ResolverViewInterface):
-        installation_token = self.token_manager.load_org_token(
-            github_view.installation_id
-        )
-        if not installation_token:
-            logger.warning('Missing installation token')
-            return
-
-        outgoing_message = message.message
-
-        if isinstance(github_view, GithubInlinePRComment):
-            with Github(auth=Auth.Token(installation_token)) as github_client:
-                repo = github_client.get_repo(github_view.full_repo_name)
-                pr = repo.get_pull(github_view.issue_number)
-                pr.create_review_comment_reply(
-                    comment_id=github_view.comment_id, body=outgoing_message
-                )
-
-        elif (
-            isinstance(github_view, GithubPRComment)
-            or isinstance(github_view, GithubIssueComment)
-            or isinstance(github_view, GithubIssue)
-        ):
-            with Github(auth=Auth.Token(installation_token)) as github_client:
-                repo = github_client.get_repo(github_view.full_repo_name)
-                issue = repo.get_issue(number=github_view.issue_number)
-                issue.create_comment(outgoing_message)
-
-        else:
-            logger.warning('Unsupported location')
-            return
-
-    async def start_job(self, github_view: ResolverViewInterface):
-        """Kick off a job with openhands agent.
-
-        1. Get user credential
-        2. Initialize new conversation with repo
-        3. Save interaction data
-        """
-        # Importing here prevents circular import
-        from server.conversation_callback_processor.github_callback_processor import (
-            GithubCallbackProcessor,
-        )
-
-        try:
-            msg_info = None
-
-            try:
-                user_info = github_view.user_info
-                logger.info(
-                    f'[GitHub] Starting job for user {user_info.username} (id={user_info.user_id})'
-                )
-
-                # Create conversation
-                user_token = await self.token_manager.get_idp_token_from_idp_user_id(
-                    str(user_info.user_id), ProviderType.GITHUB
-                )
-
-                if not user_token:
-                    logger.warning(
-                        f'[GitHub] No token found for user {user_info.username} (id={user_info.user_id})'
-                    )
-                    raise MissingSettingsError('Missing settings')
-
-                logger.info(
-                    f'[GitHub] Creating new conversation for user {user_info.username}'
-                )
-
-                secret_store = Secrets(
-                    provider_tokens=MappingProxyType(
-                        {
-                            ProviderType.GITHUB: ProviderToken(
-                                token=SecretStr(user_token),
-                                user_id=str(user_info.user_id),
-                            )
-                        }
-                    )
-                )
-
-                # We first initialize a conversation and generate the solvability report BEFORE starting the conversation runtime
-                # This helps us accumulate llm spend without requiring a running runtime. This setups us up for
-                #   1. If there is a problem starting the runtime we still have accumulated total conversation cost
-                #   2. In the future, based on the report confidence we can conditionally start the conversation
-                #   3. Once the conversation is started, its base cost will include the report's spend as well which allows us to control max budget per resolver task
-                convo_metadata = await github_view.initialize_new_conversation()
-                solvability_summary = None
-                try:
-                    if user_token:
-                        solvability_summary = await summarize_issue_solvability(
-                            github_view, user_token
-                        )
-                    else:
-                        logger.warning(
-                            '[Github]: No user token available for solvability analysis'
-                        )
-                except Exception as e:
-                    logger.warning(
-                        f'[Github]: Error summarizing issue solvability: {str(e)}'
-                    )
-
-                saas_user_auth = await get_saas_user_auth(
-                    github_view.user_info.keycloak_user_id, self.token_manager
-                )
-
-                await github_view.create_new_conversation(
-                    self.jinja_env,
-                    secret_store.provider_tokens,
-                    convo_metadata,
-                    saas_user_auth,
-                )
-
-                conversation_id = github_view.conversation_id
-
-                logger.info(
-                    f'[GitHub] Created conversation {conversation_id} for user {user_info.username}'
-                )
-
-                if not github_view.v1_enabled:
-                    # Create a GithubCallbackProcessor
-                    processor = GithubCallbackProcessor(
-                        github_view=github_view,
-                        send_summary_instruction=True,
-                    )
-
-                    # Register the callback processor
-                    register_callback_processor(conversation_id, processor)
-
-                    logger.info(
-                        f'[Github] Registered callback processor for conversation {conversation_id}'
-                    )
-
-                # Send message with conversation link
-                conversation_link = CONVERSATION_URL.format(conversation_id)
-                base_msg = f"I'm on it! {user_info.username} can [track my progress at all-hands.dev]({conversation_link})"
-                # Combine messages: include solvability report with "I'm on it!" if successful
-                if solvability_summary:
-                    msg_info = f'{base_msg}\n\n{solvability_summary}'
-                else:
-                    msg_info = base_msg
-
-            except MissingSettingsError as e:
-                logger.warning(
-                    f'[GitHub] Missing settings error for user {user_info.username}: {str(e)}'
-                )
-
-                msg_info = f'@{user_info.username} please re-login into [OpenHands Cloud]({HOST_URL}) before starting a job.'
-
-            except LLMAuthenticationError as e:
-                logger.warning(
-                    f'[GitHub] LLM authentication error for user {user_info.username}: {str(e)}'
-                )
-
-                msg_info = f'@{user_info.username} please set a valid LLM API key in [OpenHands Cloud]({HOST_URL}) before starting a job.'
-
-            except (AuthenticationError, ExpiredError, SessionExpiredError) as e:
-                logger.warning(
-                    f'[GitHub] Session expired for user {user_info.username}: {str(e)}'
-                )
-
-                msg_info = get_session_expired_message(user_info.username)
-
-            msg = self.create_outgoing_message(msg_info)
-            await self.send_message(msg, github_view)
-
-        except Exception:
-            logger.exception('[Github]: Error starting job')
-            msg = self.create_outgoing_message(
-                msg='Uh oh! There was an unexpected error starting the job :('
-            )
-            await self.send_message(msg, github_view)
-
-        try:
-            await self.data_collector.save_data(github_view)
-        except Exception:
-            logger.warning('[Github]: Error saving interaction data', exc_info=True)

enterprise/integrations/github/github_service.py

@@ -1,143 +0,0 @@
-import asyncio
-
-from integrations.store_repo_utils import store_repositories_in_db
-from pydantic import SecretStr
-from server.auth.token_manager import TokenManager
-
-from openhands.core.logger import openhands_logger as logger
-from openhands.integrations.github.github_service import GitHubService
-from openhands.integrations.service_types import ProviderType, Repository
-from openhands.server.types import AppMode
-
-
-class SaaSGitHubService(GitHubService):
-    def __init__(
-        self,
-        user_id: str | None = None,
-        external_auth_token: SecretStr | None = None,
-        external_auth_id: str | None = None,
-        token: SecretStr | None = None,
-        external_token_manager: bool = False,
-        base_domain: str | None = None,
-    ):
-        logger.debug(
-            f'SaaSGitHubService created with user_id {user_id}, external_auth_id {external_auth_id}, external_auth_token {'set' if external_auth_token else 'None'}, github_token {'set' if token else 'None'}, external_token_manager {external_token_manager}'
-        )
-        super().__init__(
-            user_id=user_id,
-            external_auth_token=external_auth_token,
-            external_auth_id=external_auth_id,
-            token=token,
-            external_token_manager=external_token_manager,
-            base_domain=base_domain,
-        )
-
-        self.external_auth_token = external_auth_token
-        self.external_auth_id = external_auth_id
-        self.token_manager = TokenManager(external=external_token_manager)
-
-    async def get_latest_token(self) -> SecretStr | None:
-        github_token = None
-        if self.external_auth_token:
-            github_token = SecretStr(
-                await self.token_manager.get_idp_token(
-                    self.external_auth_token.get_secret_value(), ProviderType.GITHUB
-                )
-            )
-            logger.debug(
-                f'Got GitHub token {github_token} from access token: {self.external_auth_token}'
-            )
-        elif self.external_auth_id:
-            offline_token = await self.token_manager.load_offline_token(
-                self.external_auth_id
-            )
-            github_token = SecretStr(
-                await self.token_manager.get_idp_token_from_offline_token(
-                    offline_token, ProviderType.GITHUB
-                )
-            )
-            logger.debug(
-                f'Got GitHub token {github_token} from external auth user ID: {self.external_auth_id}'
-            )
-        elif self.user_id:
-            github_token = SecretStr(
-                await self.token_manager.get_idp_token_from_idp_user_id(
-                    self.user_id, ProviderType.GITHUB
-                )
-            )
-            logger.debug(
-                f'Got GitHub token {github_token} from user ID: {self.user_id}'
-            )
-        else:
-            logger.warning('external_auth_token and user_id not set!')
-        return github_token
-
-    async def get_pr_patches(
-        self, owner: str, repo: str, pr_number: int, per_page: int = 30, page: int = 1
-    ):
-        """Get patches for files changed in a PR with pagination support.
-
-        Args:
-            owner: Repository owner
-            repo: Repository name
-            pr_number: Pull request number
-            per_page: Number of files per page (default: 30, max: 100)
-            page: Page number to fetch (default: 1)
-        """
-        url = f'https://api.github.com/repos/{owner}/{repo}/pulls/{pr_number}/files'
-        params = {'per_page': min(per_page, 100), 'page': page}  # GitHub max is 100
-        response, headers = await self._make_request(url, params)
-
-        # Parse pagination info from headers
-        has_next_page = 'next' in headers.get('link', '')
-        total_count = int(headers.get('total', 0))
-
-        return {
-            'files': response,
-            'pagination': {
-                'has_next_page': has_next_page,
-                'total_count': total_count,
-                'current_page': page,
-                'per_page': per_page,
-            },
-        }
-
-    async def get_repository_node_id(self, repo_id: str) -> str:
-        """
-        Get the new GitHub GraphQL node ID for a repository using REST API.
-
-        Args:
-            repo_id: Numeric repository ID as string (e.g., "123456789")
-
-        Returns:
-            New format node ID for GraphQL queries (e.g., "R_kgDOLfkiww")
-
-        Raises:
-            Exception: If the API request fails or node_id is not found
-        """
-        url = f'https://api.github.com/repositories/{repo_id}'
-        response, _ = await self._make_request(url)
-        node_id = response.get('node_id')
-        if not node_id:
-            raise Exception(f'No node_id found for repository {repo_id}')
-        return node_id
-
-    async def get_paginated_repos(self, page, per_page, sort, installation_id):
-        repositories = await super().get_paginated_repos(
-            page, per_page, sort, installation_id
-        )
-        asyncio.create_task(
-            store_repositories_in_db(repositories, self.external_auth_id)
-        )
-        return repositories
-
-    async def get_all_repositories(
-        self, sort: str, app_mode: AppMode
-    ) -> list[Repository]:
-        repositories = await super().get_all_repositories(sort, app_mode)
-        # Schedule the background task without awaiting it
-        asyncio.create_task(
-            store_repositories_in_db(repositories, self.external_auth_id)
-        )
-        # Return repositories immediately
-        return repositories

enterprise/integrations/github/github_solvability.py

@@ -1,183 +0,0 @@
-import asyncio
-import time
-
-from github import Auth, Github
-from integrations.github.github_view import (
-    GithubInlinePRComment,
-    GithubIssueComment,
-    GithubPRComment,
-    GithubViewType,
-)
-from integrations.solvability.data import load_classifier
-from integrations.solvability.models.report import SolvabilityReport
-from integrations.solvability.models.summary import SolvabilitySummary
-from integrations.utils import ENABLE_SOLVABILITY_ANALYSIS
-from pydantic import ValidationError
-from server.config import get_config
-from storage.database import session_maker
-from storage.saas_settings_store import SaasSettingsStore
-
-from openhands.core.config import LLMConfig
-from openhands.core.logger import openhands_logger as logger
-from openhands.utils.async_utils import call_sync_from_async
-from openhands.utils.utils import create_registry_and_conversation_stats
-
-
-def fetch_github_issue_context(
-    github_view: GithubViewType,
-    user_token: str,
-) -> str:
-    """Fetch full GitHub issue/PR context including title, body, and comments.
-
-    Args:
-        full_repo_name: Full repository name in the format 'owner/repo'
-        issue_number: The issue or PR number
-        user_token: GitHub user access token
-        max_comments: Maximum number of comments to fetch (default: 10)
-        max_comment_length: Maximum length of each comment to include in the context (default: 500)
-
-    Returns:
-        A comprehensive string containing the issue/PR context
-    """
-
-    # Build context string
-    context_parts = []
-
-    # Add title and body
-    context_parts.append(f'Title: {github_view.title}')
-    context_parts.append(f'Description:\n{github_view.description}')
-
-    with Github(auth=Auth.Token(user_token)) as github_client:
-        repo = github_client.get_repo(github_view.full_repo_name)
-        issue = repo.get_issue(github_view.issue_number)
-        if issue.labels:
-            labels = [label.name for label in issue.labels]
-            context_parts.append(f"Labels: {', '.join(labels)}")
-
-    for comment in github_view.previous_comments:
-        context_parts.append(f'- {comment.author}: {comment.body}')
-
-    return '\n\n'.join(context_parts)
-
-
-async def summarize_issue_solvability(
-    github_view: GithubViewType,
-    user_token: str,
-    timeout: float = 60.0 * 5,
-) -> str:
-    """Generate a solvability summary for an issue using the resolver view interface.
-
-    Args:
-        resolver_view: A resolver view interface instance (e.g., GithubIssue, GithubPRComment)
-        user_token: GitHub user access token for API access
-        timeout: Maximum time in seconds to wait for the result (default: 60.0)
-
-    Returns:
-        The solvability summary as a string
-
-    Raises:
-        ValueError: If LLM settings cannot be found for the user
-        asyncio.TimeoutError: If the operation exceeds the specified timeout
-    """
-    if not ENABLE_SOLVABILITY_ANALYSIS:
-        raise ValueError('Solvability report feature is disabled')
-
-    if github_view.user_info.keycloak_user_id is None:
-        raise ValueError(
-            f'[Solvability] No user ID found for user {github_view.user_info.username}'
-        )
-
-    # Grab the user's information so we can load their LLM configuration
-    store = SaasSettingsStore(
-        user_id=github_view.user_info.keycloak_user_id,
-        session_maker=session_maker,
-        config=get_config(),
-    )
-
-    user_settings = await store.load()
-
-    if user_settings is None:
-        raise ValueError(
-            f'[Solvability] No user settings found for user ID {github_view.user_info.user_id}'
-        )
-
-    # Check if solvability analysis is enabled for this user, exit early if
-    # needed
-    if not getattr(user_settings, 'enable_solvability_analysis', False):
-        raise ValueError(
-            f'Solvability analysis disabled for user {github_view.user_info.user_id}'
-        )
-
-    try:
-        llm_config = LLMConfig(
-            model=user_settings.llm_model,
-            api_key=user_settings.llm_api_key.get_secret_value(),
-            base_url=user_settings.llm_base_url,
-        )
-    except ValidationError as e:
-        raise ValueError(
-            f'[Solvability] Invalid LLM configuration for user {github_view.user_info.user_id}: {str(e)}'
-        )
-
-    # Fetch the full GitHub issue/PR context using the GitHub API
-    start_time = time.time()
-    issue_context = fetch_github_issue_context(github_view, user_token)
-    logger.info(
-        f'[Solvability] Grabbed issue context for {github_view.conversation_id}',
-        extra={
-            'conversation_id': github_view.conversation_id,
-            'response_latency': time.time() - start_time,
-            'full_repo_name': github_view.full_repo_name,
-            'issue_number': github_view.issue_number,
-        },
-    )
-
-    # For comment-based triggers, also include the specific comment that triggered the action
-    if isinstance(
-        github_view, (GithubIssueComment, GithubPRComment, GithubInlinePRComment)
-    ):
-        issue_context += f'\n\nTriggering Comment:\n{github_view.comment_body}'
-
-    solvability_classifier = load_classifier('default-classifier')
-
-    async with asyncio.timeout(timeout):
-        solvability_report: SolvabilityReport = await call_sync_from_async(
-            lambda: solvability_classifier.solvability_report(
-                issue_context, llm_config=llm_config
-            )
-        )
-
-        logger.info(
-            f'[Solvability] Generated report for {github_view.conversation_id}',
-            extra={
-                'conversation_id': github_view.conversation_id,
-                'report': solvability_report.model_dump(exclude=['issue']),
-            },
-        )
-
-        llm_registry, conversation_stats, _ = create_registry_and_conversation_stats(
-            get_config(),
-            github_view.conversation_id,
-            github_view.user_info.keycloak_user_id,
-            None,
-        )
-
-        solvability_summary = await call_sync_from_async(
-            lambda: SolvabilitySummary.from_report(
-                solvability_report,
-                llm=llm_registry.get_llm(
-                    service_id='solvability_analysis', config=llm_config
-                ),
-            )
-        )
-        conversation_stats.save_metrics()
-
-        logger.info(
-            f'[Solvability] Generated summary for {github_view.conversation_id}',
-            extra={
-                'conversation_id': github_view.conversation_id,
-                'summary': solvability_summary.model_dump(exclude=['content']),
-            },
-        )
-
-        return solvability_summary.format_as_markdown()

enterprise/integrations/github/github_types.py

@@ -1,26 +0,0 @@
-from enum import Enum
-
-from pydantic import BaseModel
-
-
-class WorkflowRunStatus(Enum):
-    FAILURE = 'failure'
-    COMPLETED = 'completed'
-    PENDING = 'pending'
-
-    def __eq__(self, other):
-        if isinstance(other, str):
-            return self.value == other
-        return super().__eq__(other)
-
-
-class WorkflowRun(BaseModel):
-    id: str
-    name: str
-    status: WorkflowRunStatus
-
-    model_config = {'use_enum_values': True}
-
-
-class WorkflowRunGroup(BaseModel):
-    runs: dict[str, WorkflowRun]

enterprise/integrations/github/github_v1_callback_processor.py

@@ -1,293 +0,0 @@
-import logging
-from typing import Any
-from uuid import UUID
-
-import httpx
-from github import Auth, Github, GithubIntegration
-from integrations.utils import CONVERSATION_URL, get_summary_instruction
-from pydantic import Field
-from server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY
-
-from openhands.agent_server.models import AskAgentRequest, AskAgentResponse
-from openhands.app_server.event_callback.event_callback_models import (
-    EventCallback,
-    EventCallbackProcessor,
-)
-from openhands.app_server.event_callback.event_callback_result_models import (
-    EventCallbackResult,
-    EventCallbackResultStatus,
-)
-from openhands.app_server.event_callback.util import (
-    ensure_conversation_found,
-    ensure_running_sandbox,
-    get_agent_server_url_from_sandbox,
-)
-from openhands.sdk import Event
-from openhands.sdk.event import ConversationStateUpdateEvent
-
-_logger = logging.getLogger(__name__)
-
-
-class GithubV1CallbackProcessor(EventCallbackProcessor):
-    """Callback processor for GitHub V1 integrations."""
-
-    github_view_data: dict[str, Any] = Field(default_factory=dict)
-    should_request_summary: bool = Field(default=True)
-    inline_pr_comment: bool = Field(default=False)
-
-    async def __call__(
-        self,
-        conversation_id: UUID,
-        callback: EventCallback,
-        event: Event,
-    ) -> EventCallbackResult | None:
-        """Process events for GitHub V1 integration."""
-
-        # Only handle ConversationStateUpdateEvent
-        if not isinstance(event, ConversationStateUpdateEvent):
-            return None
-
-        # Only act when execution has finished
-        if not (event.key == 'execution_status' and event.value == 'finished'):
-            return None
-
-        _logger.info('[GitHub V1] Callback agent state was %s', event)
-        _logger.info(
-            '[GitHub V1] Should request summary: %s', self.should_request_summary
-        )
-
-        if not self.should_request_summary:
-            return None
-
-        self.should_request_summary = False
-
-        try:
-            _logger.info(f'[GitHub V1] Requesting summary {conversation_id}')
-            summary = await self._request_summary(conversation_id)
-            _logger.info(
-                f'[GitHub V1] Posting summary {conversation_id}',
-                extra={'summary': summary},
-            )
-            await self._post_summary_to_github(summary)
-
-            return EventCallbackResult(
-                status=EventCallbackResultStatus.SUCCESS,
-                event_callback_id=callback.id,
-                event_id=event.id,
-                conversation_id=conversation_id,
-                detail=summary,
-            )
-        except Exception as e:
-            _logger.exception('[GitHub V1] Error processing callback: %s', e)
-
-            # Only try to post error to GitHub if we have basic requirements
-            try:
-                # Check if we have installation ID and credentials before posting
-                if (
-                    self.github_view_data.get('installation_id')
-                    and GITHUB_APP_CLIENT_ID
-                    and GITHUB_APP_PRIVATE_KEY
-                ):
-                    await self._post_summary_to_github(
-                        f'OpenHands encountered an error: **{str(e)}**.\n\n'
-                        f'[See the conversation]({CONVERSATION_URL.format(conversation_id)})'
-                        'for more information.'
-                    )
-            except Exception as post_error:
-                _logger.warning(
-                    '[GitHub V1] Failed to post error message to GitHub: %s', post_error
-                )
-
-            return EventCallbackResult(
-                status=EventCallbackResultStatus.ERROR,
-                event_callback_id=callback.id,
-                event_id=event.id,
-                conversation_id=conversation_id,
-                detail=str(e),
-            )
-
-    # -------------------------------------------------------------------------
-    # GitHub helpers
-    # -------------------------------------------------------------------------
-
-    def _get_installation_access_token(self) -> str:
-        installation_id = self.github_view_data.get('installation_id')
-
-        if not installation_id:
-            raise ValueError(
-                f'Missing installation ID for GitHub payload: {self.github_view_data}'
-            )
-
-        if not GITHUB_APP_CLIENT_ID or not GITHUB_APP_PRIVATE_KEY:
-            raise ValueError('GitHub App credentials are not configured')
-
-        github_integration = GithubIntegration(
-            auth=Auth.AppAuth(GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY),
-        )
-        token_data = github_integration.get_access_token(installation_id)
-        return token_data.token
-
-    async def _post_summary_to_github(self, summary: str) -> None:
-        """Post a summary comment to the configured GitHub issue."""
-        installation_token = self._get_installation_access_token()
-
-        if not installation_token:
-            raise RuntimeError('Missing GitHub credentials')
-
-        full_repo_name = self.github_view_data['full_repo_name']
-        issue_number = self.github_view_data['issue_number']
-
-        if self.inline_pr_comment:
-            with Github(auth=Auth.Token(installation_token)) as github_client:
-                repo = github_client.get_repo(full_repo_name)
-                pr = repo.get_pull(issue_number)
-                pr.create_review_comment_reply(
-                    comment_id=self.github_view_data.get('comment_id', ''), body=summary
-                )
-            return
-
-        with Github(auth=Auth.Token(installation_token)) as github_client:
-            repo = github_client.get_repo(full_repo_name)
-            issue = repo.get_issue(number=issue_number)
-            issue.create_comment(summary)
-
-    # -------------------------------------------------------------------------
-    # Agent / sandbox helpers
-    # -------------------------------------------------------------------------
-
-    async def _ask_question(
-        self,
-        httpx_client: httpx.AsyncClient,
-        agent_server_url: str,
-        conversation_id: UUID,
-        session_api_key: str,
-        message_content: str,
-    ) -> str:
-        """Send a message to the agent server via the V1 API and return response text."""
-        send_message_request = AskAgentRequest(question=message_content)
-
-        url = (
-            f'{agent_server_url.rstrip("/")}'
-            f'/api/conversations/{conversation_id}/ask_agent'
-        )
-        headers = {'X-Session-API-Key': session_api_key}
-        payload = send_message_request.model_dump()
-
-        try:
-            response = await httpx_client.post(
-                url,
-                json=payload,
-                headers=headers,
-                timeout=30.0,
-            )
-            response.raise_for_status()
-
-            agent_response = AskAgentResponse.model_validate(response.json())
-            return agent_response.response
-
-        except httpx.HTTPStatusError as e:
-            error_detail = f'HTTP {e.response.status_code} error'
-            try:
-                error_body = e.response.text
-                if error_body:
-                    error_detail += f': {error_body}'
-            except Exception:  # noqa: BLE001
-                pass
-
-            _logger.error(
-                '[GitHub V1] HTTP error sending message to %s: %s. '
-                'Request payload: %s. Response headers: %s',
-                url,
-                error_detail,
-                payload,
-                dict(e.response.headers),
-                exc_info=True,
-            )
-            raise Exception(f'Failed to send message to agent server: {error_detail}')
-
-        except httpx.TimeoutException:
-            error_detail = f'Request timeout after 30 seconds to {url}'
-            _logger.error(
-                '[GitHub V1] %s. Request payload: %s',
-                error_detail,
-                payload,
-                exc_info=True,
-            )
-            raise Exception(error_detail)
-
-        except httpx.RequestError as e:
-            error_detail = f'Request error to {url}: {str(e)}'
-            _logger.error(
-                '[GitHub V1] %s. Request payload: %s',
-                error_detail,
-                payload,
-                exc_info=True,
-            )
-            raise Exception(error_detail)
-
-    # -------------------------------------------------------------------------
-    # Summary orchestration
-    # -------------------------------------------------------------------------
-
-    async def _request_summary(self, conversation_id: UUID) -> str:
-        """
-        Ask the agent to produce a summary of its work and return the agent response.
-
-        NOTE: This method now returns a string (the agent server's response text)
-        and raises exceptions on errors. The wrapping into EventCallbackResult
-        is handled by __call__.
-        """
-        # Import services within the method to avoid circular imports
-        from openhands.app_server.config import (
-            get_app_conversation_info_service,
-            get_httpx_client,
-            get_sandbox_service,
-        )
-        from openhands.app_server.services.injector import InjectorState
-        from openhands.app_server.user.specifiy_user_context import (
-            ADMIN,
-            USER_CONTEXT_ATTR,
-        )
-
-        # Create injector state for dependency injection
-        state = InjectorState()
-        setattr(state, USER_CONTEXT_ATTR, ADMIN)
-
-        async with (
-            get_app_conversation_info_service(state) as app_conversation_info_service,
-            get_sandbox_service(state) as sandbox_service,
-            get_httpx_client(state) as httpx_client,
-        ):
-            # 1. Conversation lookup
-            app_conversation_info = ensure_conversation_found(
-                await app_conversation_info_service.get_app_conversation_info(
-                    conversation_id
-                ),
-                conversation_id,
-            )
-
-            # 2. Sandbox lookup + validation
-            sandbox = ensure_running_sandbox(
-                await sandbox_service.get_sandbox(app_conversation_info.sandbox_id),
-                app_conversation_info.sandbox_id,
-            )
-
-            assert (
-                sandbox.session_api_key is not None
-            ), f'No session API key for sandbox: {sandbox.id}'
-
-            # 3. URL + instruction
-            agent_server_url = get_agent_server_url_from_sandbox(sandbox)
-            agent_server_url = get_agent_server_url_from_sandbox(sandbox)
-
-            # Prepare message based on agent state
-            message_content = get_summary_instruction()
-
-            # Ask the agent and return the response text
-            return await self._ask_question(
-                httpx_client=httpx_client,
-                agent_server_url=agent_server_url,
-                conversation_id=conversation_id,
-                session_api_key=sandbox.session_api_key,
-                message_content=message_content,
-            )

enterprise/integrations/github/github_view.py

@@ -1,887 +0,0 @@
-from dataclasses import dataclass
-from uuid import UUID, uuid4
-
-from github import Auth, Github, GithubIntegration
-from github.Issue import Issue
-from integrations.github.github_types import (
-    WorkflowRun,
-    WorkflowRunGroup,
-    WorkflowRunStatus,
-)
-from integrations.models import Message
-from integrations.resolver_context import ResolverUserContext
-from integrations.types import ResolverViewInterface, UserData
-from integrations.utils import (
-    ENABLE_PROACTIVE_CONVERSATION_STARTERS,
-    ENABLE_V1_GITHUB_RESOLVER,
-    HOST,
-    HOST_URL,
-    get_oh_labels,
-    get_user_v1_enabled_setting,
-    has_exact_mention,
-)
-from jinja2 import Environment
-from server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY
-from server.auth.token_manager import TokenManager
-from server.config import get_config
-from storage.database import session_maker
-from storage.org_store import OrgStore
-from storage.proactive_conversation_store import ProactiveConversationStore
-from storage.saas_secrets_store import SaasSecretsStore
-
-from openhands.agent_server.models import SendMessageRequest
-from openhands.app_server.app_conversation.app_conversation_models import (
-    AppConversationStartRequest,
-    AppConversationStartTaskStatus,
-)
-from openhands.app_server.config import get_app_conversation_service
-from openhands.app_server.services.injector import InjectorState
-from openhands.app_server.user.specifiy_user_context import USER_CONTEXT_ATTR
-from openhands.core.logger import openhands_logger as logger
-from openhands.integrations.github.github_service import GithubServiceImpl
-from openhands.integrations.provider import PROVIDER_TOKEN_TYPE, ProviderType
-from openhands.integrations.service_types import Comment
-from openhands.sdk import TextContent
-from openhands.server.services.conversation_service import (
-    initialize_conversation,
-    start_conversation,
-)
-from openhands.server.user_auth.user_auth import UserAuth
-from openhands.storage.data_models.conversation_metadata import (
-    ConversationMetadata,
-    ConversationTrigger,
-)
-from openhands.utils.async_utils import call_sync_from_async
-
-OH_LABEL, INLINE_OH_LABEL = get_oh_labels(HOST)
-
-
-async def is_v1_enabled_for_github_resolver(user_id: str) -> bool:
-    return await get_user_v1_enabled_setting(user_id) and ENABLE_V1_GITHUB_RESOLVER
-
-
-async def get_user_proactive_conversation_setting(user_id: str | None) -> bool:
-    """Get the user's proactive conversation setting.
-
-    Args:
-        user_id: The keycloak user ID
-
-    Returns:
-        True if proactive conversations are enabled for this user, False otherwise
-
-    Note:
-        This function checks both the global environment variable kill switch AND
-        the user's individual setting. Both must be true for the function to return true.
-    """
-
-    # If no user ID is provided, we can't check user settings
-    if not user_id:
-        return False
-
-    # Check global setting first - if disabled globally, return False
-    if not ENABLE_PROACTIVE_CONVERSATION_STARTERS:
-        return False
-
-    def _get_setting():
-        org = OrgStore.get_current_org_from_keycloak_user_id(user_id)
-        if not org:
-            return False
-        return bool(org.enable_proactive_conversation_starters)
-
-    return await call_sync_from_async(_get_setting)
-
-
-# =================================================
-# SECTION: Github view types
-# =================================================
-
-
-@dataclass
-class GithubIssue(ResolverViewInterface):
-    issue_number: int
-    installation_id: int
-    full_repo_name: str
-    is_public_repo: bool
-    user_info: UserData
-    raw_payload: Message
-    conversation_id: str
-    uuid: str | None
-    should_extract: bool
-    send_summary_instruction: bool
-    title: str
-    description: str
-    previous_comments: list[Comment]
-    v1_enabled: bool
-
-    def _get_branch_name(self) -> str | None:
-        return getattr(self, 'branch_name', None)
-
-    async def _load_resolver_context(self):
-        github_service = GithubServiceImpl(
-            external_auth_id=self.user_info.keycloak_user_id
-        )
-
-        self.previous_comments = await github_service.get_issue_or_pr_comments(
-            self.full_repo_name, self.issue_number
-        )
-
-        (
-            self.title,
-            self.description,
-        ) = await github_service.get_issue_or_pr_title_and_body(
-            self.full_repo_name, self.issue_number
-        )
-
-    async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:
-        user_instructions_template = jinja_env.get_template('issue_prompt.j2')
-
-        user_instructions = user_instructions_template.render(
-            issue_number=self.issue_number,
-        )
-
-        await self._load_resolver_context()
-
-        conversation_instructions_template = jinja_env.get_template(
-            'issue_conversation_instructions.j2'
-        )
-        conversation_instructions = conversation_instructions_template.render(
-            issue_title=self.title,
-            issue_body=self.description,
-            previous_comments=self.previous_comments,
-        )
-
-        return user_instructions, conversation_instructions
-
-    async def _get_user_secrets(self):
-        secrets_store = SaasSecretsStore(
-            self.user_info.keycloak_user_id, session_maker, get_config()
-        )
-        user_secrets = await secrets_store.load()
-
-        return user_secrets.custom_secrets if user_secrets else None
-
-    async def initialize_new_conversation(self) -> ConversationMetadata:
-        # FIXME: Handle if initialize_conversation returns None
-
-        self.v1_enabled = await is_v1_enabled_for_github_resolver(
-            self.user_info.keycloak_user_id
-        )
-
-        logger.info(
-            f'[GitHub V1]: User flag found for {self.user_info.keycloak_user_id} is {self.v1_enabled}'
-        )
-        if self.v1_enabled:
-            # Create dummy conversationm metadata
-            # Don't save to conversation store
-            # V1 conversations are stored in a separate table
-            self.conversation_id = uuid4().hex
-            return ConversationMetadata(
-                conversation_id=self.conversation_id,
-                selected_repository=self.full_repo_name,
-            )
-
-        conversation_metadata: ConversationMetadata = await initialize_conversation(  # type: ignore[assignment]
-            user_id=self.user_info.keycloak_user_id,
-            conversation_id=None,
-            selected_repository=self.full_repo_name,
-            selected_branch=self._get_branch_name(),
-            conversation_trigger=ConversationTrigger.RESOLVER,
-            git_provider=ProviderType.GITHUB,
-        )
-
-        self.conversation_id = conversation_metadata.conversation_id
-        return conversation_metadata
-
-    async def create_new_conversation(
-        self,
-        jinja_env: Environment,
-        git_provider_tokens: PROVIDER_TOKEN_TYPE,
-        conversation_metadata: ConversationMetadata,
-        saas_user_auth: UserAuth,
-    ):
-        logger.info(
-            f'[GitHub V1]: User flag found for {self.user_info.keycloak_user_id} is {self.v1_enabled}'
-        )
-        if self.v1_enabled:
-            # Use V1 app conversation service
-            await self._create_v1_conversation(
-                jinja_env, saas_user_auth, conversation_metadata
-            )
-        else:
-            await self._create_v0_conversation(
-                jinja_env, git_provider_tokens, conversation_metadata
-            )
-
-    async def _create_v0_conversation(
-        self,
-        jinja_env: Environment,
-        git_provider_tokens: PROVIDER_TOKEN_TYPE,
-        conversation_metadata: ConversationMetadata,
-    ):
-        """Create conversation using the legacy V0 system."""
-        logger.info('[GitHub]: Creating V0 conversation')
-        custom_secrets = await self._get_user_secrets()
-
-        user_instructions, conversation_instructions = await self._get_instructions(
-            jinja_env
-        )
-
-        await start_conversation(
-            user_id=self.user_info.keycloak_user_id,
-            git_provider_tokens=git_provider_tokens,
-            custom_secrets=custom_secrets,
-            initial_user_msg=user_instructions,
-            image_urls=None,
-            replay_json=None,
-            conversation_id=conversation_metadata.conversation_id,
-            conversation_metadata=conversation_metadata,
-            conversation_instructions=conversation_instructions,
-        )
-
-    async def _create_v1_conversation(
-        self,
-        jinja_env: Environment,
-        saas_user_auth: UserAuth,
-        conversation_metadata: ConversationMetadata,
-    ):
-        """Create conversation using the new V1 app conversation system."""
-        logger.info('[GitHub V1]: Creating V1 conversation')
-
-        user_instructions, conversation_instructions = await self._get_instructions(
-            jinja_env
-        )
-
-        # Create the initial message request
-        initial_message = SendMessageRequest(
-            role='user', content=[TextContent(text=user_instructions)]
-        )
-
-        # Create the GitHub V1 callback processor
-        github_callback_processor = self._create_github_v1_callback_processor()
-
-        # Get the app conversation service and start the conversation
-        injector_state = InjectorState()
-
-        # Create the V1 conversation start request with the callback processor
-        start_request = AppConversationStartRequest(
-            conversation_id=UUID(conversation_metadata.conversation_id),
-            system_message_suffix=conversation_instructions,
-            initial_message=initial_message,
-            selected_repository=self.full_repo_name,
-            selected_branch=self._get_branch_name(),
-            git_provider=ProviderType.GITHUB,
-            title=f'GitHub Issue #{self.issue_number}: {self.title}',
-            trigger=ConversationTrigger.RESOLVER,
-            processors=[
-                github_callback_processor
-            ],  # Pass the callback processor directly
-        )
-
-        # Set up the GitHub user context for the V1 system
-        github_user_context = ResolverUserContext(saas_user_auth=saas_user_auth)
-        setattr(injector_state, USER_CONTEXT_ATTR, github_user_context)
-
-        async with get_app_conversation_service(
-            injector_state
-        ) as app_conversation_service:
-            async for task in app_conversation_service.start_app_conversation(
-                start_request
-            ):
-                if task.status == AppConversationStartTaskStatus.ERROR:
-                    logger.error(f'Failed to start V1 conversation: {task.detail}')
-                    raise RuntimeError(
-                        f'Failed to start V1 conversation: {task.detail}'
-                    )
-
-    def _create_github_v1_callback_processor(self):
-        """Create a V1 callback processor for GitHub integration."""
-        from integrations.github.github_v1_callback_processor import (
-            GithubV1CallbackProcessor,
-        )
-
-        # Create and return the GitHub V1 callback processor
-        return GithubV1CallbackProcessor(
-            github_view_data={
-                'issue_number': self.issue_number,
-                'full_repo_name': self.full_repo_name,
-                'installation_id': self.installation_id,
-            },
-            send_summary_instruction=self.send_summary_instruction,
-        )
-
-
-@dataclass
-class GithubIssueComment(GithubIssue):
-    comment_body: str
-    comment_id: int
-
-    async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:
-        user_instructions_template = jinja_env.get_template('issue_prompt.j2')
-
-        await self._load_resolver_context()
-
-        user_instructions = user_instructions_template.render(
-            issue_comment=self.comment_body
-        )
-
-        conversation_instructions_template = jinja_env.get_template(
-            'issue_conversation_instructions.j2'
-        )
-        conversation_instructions = conversation_instructions_template.render(
-            issue_number=self.issue_number,
-            issue_title=self.title,
-            issue_body=self.description,
-            previous_comments=self.previous_comments,
-        )
-
-        return user_instructions, conversation_instructions
-
-
-@dataclass
-class GithubPRComment(GithubIssueComment):
-    branch_name: str
-
-    async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:
-        user_instructions_template = jinja_env.get_template('pr_update_prompt.j2')
-        await self._load_resolver_context()
-
-        user_instructions = user_instructions_template.render(
-            pr_comment=self.comment_body,
-        )
-
-        conversation_instructions_template = jinja_env.get_template(
-            'pr_update_conversation_instructions.j2'
-        )
-        conversation_instructions = conversation_instructions_template.render(
-            pr_number=self.issue_number,
-            branch_name=self.branch_name,
-            pr_title=self.title,
-            pr_body=self.description,
-            comments=self.previous_comments,
-        )
-
-        return user_instructions, conversation_instructions
-
-
-@dataclass
-class GithubInlinePRComment(GithubPRComment):
-    file_location: str
-    line_number: int
-    comment_node_id: str
-
-    async def _load_resolver_context(self):
-        github_service = GithubServiceImpl(
-            external_auth_id=self.user_info.keycloak_user_id
-        )
-
-        (
-            self.title,
-            self.description,
-        ) = await github_service.get_issue_or_pr_title_and_body(
-            self.full_repo_name, self.issue_number
-        )
-
-        self.previous_comments = await github_service.get_review_thread_comments(
-            self.comment_node_id, self.full_repo_name, self.issue_number
-        )
-
-    async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:
-        user_instructions_template = jinja_env.get_template('pr_update_prompt.j2')
-        await self._load_resolver_context()
-
-        user_instructions = user_instructions_template.render(
-            pr_comment=self.comment_body,
-        )
-
-        conversation_instructions_template = jinja_env.get_template(
-            'pr_update_conversation_instructions.j2'
-        )
-        conversation_instructions = conversation_instructions_template.render(
-            pr_number=self.issue_number,
-            pr_title=self.title,
-            pr_body=self.description,
-            branch_name=self.branch_name,
-            file_location=self.file_location,
-            line_number=self.line_number,
-            comments=self.previous_comments,
-        )
-
-        return user_instructions, conversation_instructions
-
-    def _create_github_v1_callback_processor(self):
-        """Create a V1 callback processor for GitHub integration."""
-        from integrations.github.github_v1_callback_processor import (
-            GithubV1CallbackProcessor,
-        )
-
-        # Create and return the GitHub V1 callback processor
-        return GithubV1CallbackProcessor(
-            github_view_data={
-                'issue_number': self.issue_number,
-                'full_repo_name': self.full_repo_name,
-                'installation_id': self.installation_id,
-                'comment_id': self.comment_id,
-            },
-            inline_pr_comment=True,
-            send_summary_instruction=self.send_summary_instruction,
-        )
-
-
-@dataclass
-class GithubFailingAction:
-    unqiue_suggestions_header: str = (
-        'Looks like there are a few issues preventing this PR from being merged!'
-    )
-
-    @staticmethod
-    def get_latest_sha(pr: Issue) -> str:
-        pr_obj = pr.as_pull_request()
-        return pr_obj.head.sha
-
-    @staticmethod
-    def create_retrieve_workflows_callback(pr: Issue, head_sha: str):
-        def get_all_workflows():
-            repo = pr.repository
-            workflows = repo.get_workflow_runs(head_sha=head_sha)
-
-            runs = {}
-
-            for workflow in workflows:
-                conclusion = workflow.conclusion
-                workflow_conclusion = WorkflowRunStatus.COMPLETED
-                if conclusion is None:
-                    workflow_conclusion = WorkflowRunStatus.PENDING  # type: ignore[unreachable]
-                elif conclusion == WorkflowRunStatus.FAILURE.value:
-                    workflow_conclusion = WorkflowRunStatus.FAILURE
-
-                runs[str(workflow.id)] = WorkflowRun(
-                    id=str(workflow.id), name=workflow.name, status=workflow_conclusion
-                )
-
-            return WorkflowRunGroup(runs=runs)
-
-        return get_all_workflows
-
-    @staticmethod
-    def delete_old_comment_if_exists(pr: Issue):
-        paginated_comments = pr.get_comments()
-        for page in range(paginated_comments.totalCount):
-            comments = paginated_comments.get_page(page)
-            for comment in comments:
-                if GithubFailingAction.unqiue_suggestions_header in comment.body:
-                    comment.delete()
-
-    @staticmethod
-    def get_suggestions(
-        failed_jobs: dict, pr_number: int, branch_name: str | None = None
-    ) -> str:
-        issues = []
-
-        # Collect failing actions with their specific names
-        if failed_jobs['actions']:
-            failing_actions = failed_jobs['actions']
-            issues.append(('GitHub Actions are failing:', False))
-            for action in failing_actions:
-                issues.append((action, True))
-
-        if any(failed_jobs['merge conflict']):
-            issues.append(('There are merge conflicts', False))
-
-        # Format each line with proper indentation and dashes
-        formatted_issues = []
-        for issue, is_nested in issues:
-            if is_nested:
-                formatted_issues.append(f'  - {issue}')
-            else:
-                formatted_issues.append(f'- {issue}')
-        issues_text = '\n'.join(formatted_issues)
-
-        # Build list of possible suggestions based on actual issues
-        suggestions = []
-        branch_info = f' at branch `{branch_name}`' if branch_name else ''
-
-        if any(failed_jobs['merge conflict']):
-            suggestions.append(
-                f'@OpenHands please fix the merge conflicts on PR #{pr_number}{branch_info}'
-            )
-        if any(failed_jobs['actions']):
-            suggestions.append(
-                f'@OpenHands please fix the failing actions on PR #{pr_number}{branch_info}'
-            )
-
-        # Take at most 2 suggestions
-        suggestions = suggestions[:2]
-
-        help_text = """If you'd like me to help, just leave a comment, like
-
-```
-{}
-```
-
-Feel free to include any additional details that might help me get this PR into a better state.
-
-<sub><sup>You can manage your notification [settings]({})</sup></sub>""".format(
-            '\n```\n\nor\n\n```\n'.join(suggestions), f'{HOST_URL}/settings/app'
-        )
-
-        return f'{GithubFailingAction.unqiue_suggestions_header}\n\n{issues_text}\n\n{help_text}'
-
-    @staticmethod
-    def leave_requesting_comment(pr: Issue, failed_runs: WorkflowRunGroup):
-        failed_jobs: dict = {'actions': [], 'merge conflict': []}
-
-        pr_obj = pr.as_pull_request()
-        if not pr_obj.mergeable:
-            failed_jobs['merge conflict'].append('Merge conflict detected')
-
-        for _, workflow_run in failed_runs.runs.items():
-            if workflow_run.status == WorkflowRunStatus.FAILURE:
-                failed_jobs['actions'].append(workflow_run.name)
-
-        logger.info(f'[GitHub] Found failing jobs for PR #{pr.number}: {failed_jobs}')
-
-        # Get the branch name
-        branch_name = pr_obj.head.ref
-
-        # Get suggestions with branch name included
-        suggestions = GithubFailingAction.get_suggestions(
-            failed_jobs, pr.number, branch_name
-        )
-
-        GithubFailingAction.delete_old_comment_if_exists(pr)
-        pr.create_comment(suggestions)
-
-
-GithubViewType = (
-    GithubInlinePRComment | GithubPRComment | GithubIssueComment | GithubIssue
-)
-
-
-# =================================================
-# SECTION: Factory to create appriorate Github view
-# =================================================
-
-
-class GithubFactory:
-    @staticmethod
-    def is_labeled_issue(message: Message):
-        payload = message.message.get('payload', {})
-        action = payload.get('action', '')
-
-        if action == 'labeled' and 'label' in payload and 'issue' in payload:
-            label_name = payload['label'].get('name', '')
-            if label_name == OH_LABEL:
-                return True
-
-        return False
-
-    @staticmethod
-    def is_issue_comment(message: Message):
-        payload = message.message.get('payload', {})
-        action = payload.get('action', '')
-
-        if (
-            action == 'created'
-            and 'comment' in payload
-            and 'issue' in payload
-            and 'pull_request' not in payload['issue']
-        ):
-            comment_body = payload['comment']['body']
-            if has_exact_mention(comment_body, INLINE_OH_LABEL):
-                return True
-
-        return False
-
-    @staticmethod
-    def is_pr_comment(message: Message):
-        payload = message.message.get('payload', {})
-        action = payload.get('action', '')
-
-        if (
-            action == 'created'
-            and 'comment' in payload
-            and 'issue' in payload
-            and 'pull_request' in payload['issue']
-        ):
-            comment_body = payload['comment'].get('body', '')
-            if has_exact_mention(comment_body, INLINE_OH_LABEL):
-                return True
-
-        return False
-
-    @staticmethod
-    def is_inline_pr_comment(message: Message):
-        payload = message.message.get('payload', {})
-        action = payload.get('action', '')
-
-        if action == 'created' and 'comment' in payload and 'pull_request' in payload:
-            comment_body = payload['comment'].get('body', '')
-            if has_exact_mention(comment_body, INLINE_OH_LABEL):
-                return True
-
-        return False
-
-    @staticmethod
-    def is_eligible_for_conversation_starter(message: Message):
-        if not ENABLE_PROACTIVE_CONVERSATION_STARTERS:
-            return False
-
-        payload = message.message.get('payload', {})
-        action = payload.get('action', '')
-
-        if not (action == 'completed' and 'workflow_run' in payload):
-            return False
-
-        return True
-
-    @staticmethod
-    async def trigger_conversation_starter(message: Message):
-        """Trigger a conversation starter when a workflow fails.
-
-        This is the updated version that checks user settings.
-        """
-        payload = message.message.get('payload', {})
-        workflow_payload = payload['workflow_run']
-        status = WorkflowRunStatus.COMPLETED
-
-        if workflow_payload['conclusion'] == 'failure':
-            status = WorkflowRunStatus.FAILURE
-        elif workflow_payload['conclusion'] is None:
-            status = WorkflowRunStatus.PENDING
-
-        workflow_run = WorkflowRun(
-            id=str(workflow_payload['id']), name=workflow_payload['name'], status=status
-        )
-
-        selected_repo = GithubFactory.get_full_repo_name(payload['repository'])
-        head_branch = payload['workflow_run']['head_branch']
-
-        # Get the user ID to check their settings
-        user_id = None
-        try:
-            sender_id = payload['sender']['id']
-            token_manager = TokenManager()
-            user_id = await token_manager.get_user_id_from_idp_user_id(
-                sender_id, ProviderType.GITHUB
-            )
-        except (KeyError, Exception) as e:
-            logger.warning(
-                f'Failed to get user ID for proactive conversation check: {str(e)}'
-            )
-
-        # Check if proactive conversations are enabled for this user
-        if not await get_user_proactive_conversation_setting(user_id):
-            return False
-
-        def _interact_with_github() -> Issue | None:
-            with GithubIntegration(
-                auth=Auth.AppAuth(GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY)
-            ) as integration:
-                access_token = integration.get_access_token(
-                    payload['installation']['id']
-                ).token
-
-            with Github(auth=Auth.Token(access_token)) as gh:
-                repo = gh.get_repo(selected_repo)
-                login = (
-                    payload['organization']['login']
-                    if 'organization' in payload
-                    else payload['sender']['login']
-                )
-
-                # See if a pull request is open
-                open_pulls = repo.get_pulls(state='open', head=f'{login}:{head_branch}')
-                if open_pulls.totalCount > 0:
-                    prs = open_pulls.get_page(0)
-                    relevant_pr = prs[0]
-                    issue = repo.get_issue(number=relevant_pr.number)
-                    return issue
-
-            return None
-
-        issue: Issue | None = await call_sync_from_async(_interact_with_github)
-        if not issue:
-            return False
-
-        incoming_commit = payload['workflow_run']['head_sha']
-        latest_sha = GithubFailingAction.get_latest_sha(issue)
-        if latest_sha != incoming_commit:
-            # Return as this commit is not the latest
-            return False
-
-        convo_store = ProactiveConversationStore()
-        workflow_group = await convo_store.store_workflow_information(
-            provider=ProviderType.GITHUB,
-            repo_id=payload['repository']['id'],
-            incoming_commit=incoming_commit,
-            workflow=workflow_run,
-            pr_number=issue.number,
-            get_all_workflows=GithubFailingAction.create_retrieve_workflows_callback(
-                issue, incoming_commit
-            ),
-        )
-
-        if not workflow_group:
-            return False
-
-        logger.info(
-            f'[GitHub] Workflow completed for {selected_repo}#{issue.number} on branch {head_branch}'
-        )
-        GithubFailingAction.leave_requesting_comment(issue, workflow_group)
-
-        return False
-
-    @staticmethod
-    def get_full_repo_name(repo_obj: dict) -> str:
-        owner = repo_obj['owner']['login']
-        repo_name = repo_obj['name']
-        return f'{owner}/{repo_name}'
-
-    @staticmethod
-    async def create_github_view_from_payload(
-        message: Message, keycloak_user_id: str
-    ) -> ResolverViewInterface:
-        """Create the appropriate class (GithubIssue or GithubPRComment) based on the payload.
-        Also return metadata about the event (e.g., action type).
-        """
-        payload = message.message.get('payload', {})
-        repo_obj = payload['repository']
-        user_id = payload['sender']['id']
-        username = payload['sender']['login']
-
-        selected_repo = GithubFactory.get_full_repo_name(repo_obj)
-        is_public_repo = not repo_obj.get('private', True)
-        user_info = UserData(
-            user_id=user_id, username=username, keycloak_user_id=keycloak_user_id
-        )
-
-        installation_id = message.message['installation']
-
-        if GithubFactory.is_labeled_issue(message):
-            issue_number = payload['issue']['number']
-            logger.info(
-                f'[GitHub] Creating view for labeled issue from {username} in {selected_repo}#{issue_number}'
-            )
-            return GithubIssue(
-                issue_number=issue_number,
-                installation_id=installation_id,
-                full_repo_name=selected_repo,
-                is_public_repo=is_public_repo,
-                raw_payload=message,
-                user_info=user_info,
-                conversation_id='',
-                uuid=str(uuid4()),
-                should_extract=True,
-                send_summary_instruction=True,
-                title='',
-                description='',
-                previous_comments=[],
-                v1_enabled=False,
-            )
-
-        elif GithubFactory.is_issue_comment(message):
-            issue_number = payload['issue']['number']
-            comment_body = payload['comment']['body']
-            comment_id = payload['comment']['id']
-            logger.info(
-                f'[GitHub] Creating view for issue comment from {username} in {selected_repo}#{issue_number}'
-            )
-            return GithubIssueComment(
-                issue_number=issue_number,
-                comment_body=comment_body,
-                comment_id=comment_id,
-                installation_id=installation_id,
-                full_repo_name=selected_repo,
-                is_public_repo=is_public_repo,
-                raw_payload=message,
-                user_info=user_info,
-                conversation_id='',
-                uuid=None,
-                should_extract=True,
-                send_summary_instruction=True,
-                title='',
-                description='',
-                previous_comments=[],
-                v1_enabled=False,
-            )
-
-        elif GithubFactory.is_pr_comment(message):
-            issue_number = payload['issue']['number']
-            logger.info(
-                f'[GitHub] Creating view for PR comment from {username} in {selected_repo}#{issue_number}'
-            )
-
-            access_token = ''
-            with GithubIntegration(
-                auth=Auth.AppAuth(GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY)
-            ) as integration:
-                access_token = integration.get_access_token(installation_id).token
-
-            head_ref = None
-            with Github(auth=Auth.Token(access_token)) as gh:
-                repo = gh.get_repo(selected_repo)
-                pull_request = repo.get_pull(issue_number)
-                head_ref = pull_request.head.ref
-                logger.info(
-                    f'[GitHub] Found PR branch {head_ref} for {selected_repo}#{issue_number}'
-                )
-
-            comment_id = payload['comment']['id']
-            return GithubPRComment(
-                issue_number=issue_number,
-                branch_name=head_ref,
-                comment_body=payload['comment']['body'],
-                comment_id=comment_id,
-                installation_id=installation_id,
-                full_repo_name=selected_repo,
-                is_public_repo=is_public_repo,
-                raw_payload=message,
-                user_info=user_info,
-                conversation_id='',
-                uuid=None,
-                should_extract=True,
-                send_summary_instruction=True,
-                title='',
-                description='',
-                previous_comments=[],
-                v1_enabled=False,
-            )
-
-        elif GithubFactory.is_inline_pr_comment(message):
-            pr_number = payload['pull_request']['number']
-            branch_name = payload['pull_request']['head']['ref']
-            comment_id = payload['comment']['id']
-            comment_node_id = payload['comment']['node_id']
-            file_path = payload['comment']['path']
-            line_number = payload['comment']['line']
-            logger.info(
-                f'[GitHub] Creating view for inline PR comment from {username} in {selected_repo}#{pr_number} at {file_path}'
-            )
-
-            return GithubInlinePRComment(
-                issue_number=pr_number,
-                branch_name=branch_name,
-                comment_body=payload['comment']['body'],
-                comment_node_id=comment_node_id,
-                comment_id=comment_id,
-                file_location=file_path,
-                line_number=line_number,
-                installation_id=installation_id,
-                full_repo_name=selected_repo,
-                is_public_repo=is_public_repo,
-                raw_payload=message,
-                user_info=user_info,
-                conversation_id='',
-                uuid=None,
-                should_extract=True,
-                send_summary_instruction=True,
-                title='',
-                description='',
-                previous_comments=[],
-                v1_enabled=False,
-            )
-
-        else:
-            raise ValueError(
-                "Invalid payload: must contain either 'issue' or 'pull_request'"
-            )

enterprise/integrations/github/queries.py

@@ -1,102 +0,0 @@
-PR_QUERY_BY_NODE_ID = """
-query($nodeId: ID!, $pr_number: Int!, $commits_after: String, $comments_after: String, $reviews_after: String) {
-    node(id: $nodeId) {
-        ... on Repository {
-            name
-            owner {
-                login
-            }
-            languages(first: 10, orderBy: {field: SIZE, direction: DESC}) {
-                nodes {
-                    name
-                }
-            }
-            pullRequest(number: $pr_number) {
-                number
-                title
-                body
-                author {
-                    login
-                }
-                merged
-                mergedAt
-                mergedBy {
-                    login
-                }
-                state
-                mergeCommit {
-                    oid
-                }
-                comments(first: 50, after: $comments_after) {
-                    pageInfo {
-                        hasNextPage
-                        endCursor
-                    }
-                    nodes {
-                        author {
-                            login
-                        }
-                        body
-                        createdAt
-                    }
-                }
-                commits(first: 50, after: $commits_after) {
-                    pageInfo {
-                        hasNextPage
-                        endCursor
-                    }
-                    nodes {
-                        commit {
-                            oid
-                            message
-                            committedDate
-                            author {
-                                name
-                                email
-                                user {
-                                    login
-                                }
-                            }
-                            additions
-                            deletions
-                            changedFiles
-                        }
-                    }
-                }
-                reviews(first: 50, after: $reviews_after) {
-                    pageInfo {
-                        hasNextPage
-                        endCursor
-                    }
-                    nodes {
-                        author {
-                            login
-                        }
-                        body
-                        state
-                        createdAt
-                        comments(first: 50) {
-                            pageInfo {
-                                hasNextPage
-                                endCursor
-                            }
-                            nodes {
-                                author {
-                                    login
-                                }
-                                body
-                                createdAt
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    rateLimit {
-        remaining
-        limit
-        resetAt
-    }
-}
-"""

enterprise/integrations/gitlab/gitlab_manager.py

@@ -1,273 +0,0 @@
-from types import MappingProxyType
-
-from integrations.gitlab.gitlab_view import (
-    GitlabFactory,
-    GitlabInlineMRComment,
-    GitlabIssue,
-    GitlabIssueComment,
-    GitlabMRComment,
-    GitlabViewType,
-)
-from integrations.manager import Manager
-from integrations.models import Message, SourceType
-from integrations.types import ResolverViewInterface
-from integrations.utils import (
-    CONVERSATION_URL,
-    HOST_URL,
-    OPENHANDS_RESOLVER_TEMPLATES_DIR,
-    get_session_expired_message,
-)
-from jinja2 import Environment, FileSystemLoader
-from pydantic import SecretStr
-from server.auth.token_manager import TokenManager
-from server.utils.conversation_callback_utils import register_callback_processor
-
-from openhands.core.logger import openhands_logger as logger
-from openhands.integrations.gitlab.gitlab_service import GitLabServiceImpl
-from openhands.integrations.provider import ProviderToken, ProviderType
-from openhands.server.types import (
-    LLMAuthenticationError,
-    MissingSettingsError,
-    SessionExpiredError,
-)
-from openhands.storage.data_models.secrets import Secrets
-
-
-class GitlabManager(Manager):
-    def __init__(self, token_manager: TokenManager, data_collector: None = None):
-        self.token_manager = token_manager
-
-        self.jinja_env = Environment(
-            loader=FileSystemLoader(OPENHANDS_RESOLVER_TEMPLATES_DIR + 'gitlab')
-        )
-
-    def _confirm_incoming_source_type(self, message: Message):
-        if message.source != SourceType.GITLAB:
-            raise ValueError(f'Unexpected message source {message.source}')
-
-    async def _user_has_write_access_to_repo(
-        self, project_id: str, user_id: str
-    ) -> bool:
-        """
-        Check if the user has write access to the repository (can pull/push changes and open merge requests).
-
-        Args:
-            project_id: The ID of the GitLab project
-            username: The username of the user
-            user_id: The GitLab user ID
-
-        Returns:
-            bool: True if the user has write access to the repository, False otherwise
-        """
-
-        keycloak_user_id = await self.token_manager.get_user_id_from_idp_user_id(
-            user_id, ProviderType.GITLAB
-        )
-        if keycloak_user_id is None:
-            logger.warning(f'Got invalid keyloak user id for GitLab User {user_id}')
-            return False
-
-        # Importing here prevents circular import
-        from integrations.gitlab.gitlab_service import SaaSGitLabService
-
-        gitlab_service: SaaSGitLabService = GitLabServiceImpl(
-            external_auth_id=keycloak_user_id
-        )
-
-        return await gitlab_service.user_has_write_access(project_id)
-
-    async def receive_message(self, message: Message):
-        self._confirm_incoming_source_type(message)
-        if await self.is_job_requested(message):
-            gitlab_view = await GitlabFactory.create_gitlab_view_from_payload(
-                message, self.token_manager
-            )
-            logger.info(
-                f'[GitLab] Creating job for {gitlab_view.user_info.username} in {gitlab_view.full_repo_name}#{gitlab_view.issue_number}'
-            )
-
-            await self.start_job(gitlab_view)
-
-    async def is_job_requested(self, message) -> bool:
-        self._confirm_incoming_source_type(message)
-        if not (
-            GitlabFactory.is_labeled_issue(message)
-            or GitlabFactory.is_issue_comment(message)
-            or GitlabFactory.is_mr_comment(message)
-            or GitlabFactory.is_mr_comment(message, inline=True)
-        ):
-            return False
-
-        payload = message.message['payload']
-
-        repo_obj = payload['project']
-        project_id = repo_obj['id']
-        selected_project = repo_obj['path_with_namespace']
-        user = payload['user']
-        user_id = user['id']
-        username = user['username']
-
-        logger.info(
-            f'[GitLab] Checking permissions for {username} in {selected_project}'
-        )
-
-        has_write_access = await self._user_has_write_access_to_repo(
-            project_id=str(project_id), user_id=user_id
-        )
-
-        logger.info(
-            f'[GitLab]: {username} access in {selected_project}: {has_write_access}'
-        )
-        # Check if the user has write access to the repository
-        return has_write_access
-
-    async def send_message(self, message: Message, gitlab_view: ResolverViewInterface):
-        """
-        Send a message to GitLab based on the view type.
-
-        Args:
-            message: The message to send
-            gitlab_view: The GitLab view object containing issue/PR/comment info
-        """
-        keycloak_user_id = gitlab_view.user_info.keycloak_user_id
-
-        # Importing here prevents circular import
-        from integrations.gitlab.gitlab_service import SaaSGitLabService
-
-        gitlab_service: SaaSGitLabService = GitLabServiceImpl(
-            external_auth_id=keycloak_user_id
-        )
-
-        outgoing_message = message.message
-
-        if isinstance(gitlab_view, GitlabInlineMRComment) or isinstance(
-            gitlab_view, GitlabMRComment
-        ):
-            await gitlab_service.reply_to_mr(
-                gitlab_view.project_id,
-                gitlab_view.issue_number,
-                gitlab_view.discussion_id,
-                message.message,
-            )
-
-        elif isinstance(gitlab_view, GitlabIssueComment):
-            await gitlab_service.reply_to_issue(
-                gitlab_view.project_id,
-                gitlab_view.issue_number,
-                gitlab_view.discussion_id,
-                outgoing_message,
-            )
-        elif isinstance(gitlab_view, GitlabIssue):
-            await gitlab_service.reply_to_issue(
-                gitlab_view.project_id,
-                gitlab_view.issue_number,
-                None,  # no discussion id, issue is tagged
-                outgoing_message,
-            )
-        else:
-            logger.warning(
-                f'[GitLab] Unsupported view type: {type(gitlab_view).__name__}'
-            )
-
-    async def start_job(self, gitlab_view: GitlabViewType):
-        """
-        Start a job for the GitLab view.
-
-        Args:
-            gitlab_view: The GitLab view object containing issue/PR/comment info
-        """
-        # Importing here prevents circular import
-        from server.conversation_callback_processor.gitlab_callback_processor import (
-            GitlabCallbackProcessor,
-        )
-
-        try:
-            try:
-                user_info = gitlab_view.user_info
-
-                logger.info(
-                    f'[GitLab] Starting job for {user_info.username} in {gitlab_view.full_repo_name}#{gitlab_view.issue_number}'
-                )
-
-                user_token = await self.token_manager.get_idp_token_from_idp_user_id(
-                    str(user_info.user_id), ProviderType.GITLAB
-                )
-
-                if not user_token:
-                    logger.warning(
-                        f'[GitLab] No token found for user {user_info.username} (id={user_info.user_id})'
-                    )
-                    raise MissingSettingsError('Missing settings')
-
-                logger.info(
-                    f'[GitLab] Creating new conversation for user {user_info.username}'
-                )
-
-                secret_store = Secrets(
-                    provider_tokens=MappingProxyType(
-                        {
-                            ProviderType.GITLAB: ProviderToken(
-                                token=SecretStr(user_token),
-                                user_id=str(user_info.user_id),
-                            )
-                        }
-                    )
-                )
-
-                await gitlab_view.create_new_conversation(
-                    self.jinja_env, secret_store.provider_tokens
-                )
-
-                conversation_id = gitlab_view.conversation_id
-
-                logger.info(
-                    f'[GitLab] Created conversation {conversation_id} for user {user_info.username}'
-                )
-
-                # Create a GitlabCallbackProcessor for this conversation
-                processor = GitlabCallbackProcessor(
-                    gitlab_view=gitlab_view,
-                    send_summary_instruction=True,
-                )
-
-                # Register the callback processor
-                register_callback_processor(conversation_id, processor)
-
-                logger.info(
-                    f'[GitLab] Created callback processor for conversation {conversation_id}'
-                )
-
-                conversation_link = CONVERSATION_URL.format(conversation_id)
-                msg_info = f"I'm on it! {user_info.username} can [track my progress at all-hands.dev]({conversation_link})"
-
-            except MissingSettingsError as e:
-                logger.warning(
-                    f'[GitLab] Missing settings error for user {user_info.username}: {str(e)}'
-                )
-
-                msg_info = f'@{user_info.username} please re-login into [OpenHands Cloud]({HOST_URL}) before starting a job.'
-
-            except LLMAuthenticationError as e:
-                logger.warning(
-                    f'[GitLab] LLM authentication error for user {user_info.username}: {str(e)}'
-                )
-
-                msg_info = f'@{user_info.username} please set a valid LLM API key in [OpenHands Cloud]({HOST_URL}) before starting a job.'
-
-            except SessionExpiredError as e:
-                logger.warning(
-                    f'[GitLab] Session expired for user {user_info.username}: {str(e)}'
-                )
-
-                msg_info = get_session_expired_message(user_info.username)
-
-            # Send the acknowledgment message
-            msg = self.create_outgoing_message(msg_info)
-            await self.send_message(msg, gitlab_view)
-
-        except Exception as e:
-            logger.exception(f'[GitLab] Error starting job: {str(e)}')
-            msg = self.create_outgoing_message(
-                msg='Uh oh! There was an unexpected error starting the job :('
-            )
-            await self.send_message(msg, gitlab_view)