Add bot-bump-kernel-version-to-sglang workflow (#12794)

.github/workflows/bot-bump-kernel-version-to-sglang.yml

@@ -0,0 +1,55 @@
+name: Bot Bump Kernel Version to SGLang
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  bump-kernel-version-to-sglang:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install Python dependencies
+        run: |
+          pip install tomli
+
+      - name: Check if sync is needed
+        id: check_sync
+        run: |
+          python scripts/release/check_kernel_version_to_sglang.py
+
+      - name: Configure Git and branch
+        if: steps.check_sync.outputs.needs_sync == 'true'
+        run: |
+          git config user.name "sglang-bot"
+          git config user.email "sglang-bot@users.noreply.github.com"
+          RANDOM_SUFFIX=$(echo $RANDOM | md5sum | head -c 4)
+          KERNEL_VERSION="${{ steps.check_sync.outputs.kernel_version }}"
+          BRANCH_NAME="bot/bump-kernel-version-to-sglang-${KERNEL_VERSION}-${RANDOM_SUFFIX}"
+          git checkout -b "$BRANCH_NAME"
+          echo "BRANCH_NAME=$BRANCH_NAME" >> $GITHUB_ENV
+          echo "KERNEL_VERSION=$KERNEL_VERSION" >> $GITHUB_ENV
+
+      - name: Run kernel version bump script
+        if: steps.check_sync.outputs.needs_sync == 'true'
+        run: |
+          python scripts/release/bump_kernel_version_to_sglang.py
+
+      - name: Commit and create PR
+        if: steps.check_sync.outputs.needs_sync == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.GH_PAT_FOR_PULL_REQUEST }}
+        run: |
+          bash scripts/release/commit_and_pr_kernel_to_sglang.sh "$KERNEL_VERSION" "$BRANCH_NAME"

scripts/release/bump_kernel_version_to_sglang.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Bump sgl-kernel version in SGLang files to match the version in sgl-kernel/pyproject.toml.
+Updates:
+  - python/pyproject.toml
+  - python/sglang/srt/entrypoints/engine.py
+  - docker/Dockerfile
+"""
+
+import re
+import sys
+from pathlib import Path
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    import tomli as tomllib  # Fallback for older Python versions
+
+
+def get_kernel_version_from_source() -> str:
+    """Extract version from sgl-kernel/pyproject.toml"""
+    pyproject_path = Path("sgl-kernel/pyproject.toml")
+
+    if not pyproject_path.exists():
+        print(f"Error: {pyproject_path} not found")
+        sys.exit(1)
+
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    version = data.get("project", {}).get("version")
+    if not version:
+        print("Error: Could not find version in sgl-kernel/pyproject.toml")
+        sys.exit(1)
+
+    return version
+
+
+def update_python_pyproject(new_version: str) -> bool:
+    """Update sgl-kernel version in python/pyproject.toml"""
+    pyproject_path = Path("python/pyproject.toml")
+
+    if not pyproject_path.exists():
+        print(f"Error: {pyproject_path} not found")
+        sys.exit(1)
+
+    content = pyproject_path.read_text()
+
+    # Replace "sgl-kernel==x.x.x" with new version
+    new_content = re.sub(
+        r'"sgl-kernel==[^"]+"',
+        f'"sgl-kernel=={new_version}"',
+        content,
+    )
+
+    if content == new_content:
+        print("No changes needed in python/pyproject.toml")
+        return False
+
+    pyproject_path.write_text(new_content)
+    print(f"✓ Updated python/pyproject.toml to version {new_version}")
+    return True
+
+
+def update_engine_py(new_version: str) -> bool:
+    """Update sgl-kernel version in python/sglang/srt/entrypoints/engine.py"""
+    engine_path = Path("python/sglang/srt/entrypoints/engine.py")
+
+    if not engine_path.exists():
+        print(f"Error: {engine_path} not found")
+        sys.exit(1)
+
+    content = engine_path.read_text()
+
+    # Replace version in assert_pkg_version("sgl-kernel", "version", ...)
+    new_content = re.sub(
+        r'(assert_pkg_version\s*\(\s*"sgl-kernel"\s*,\s*)"[^"]+"',
+        rf'\1"{new_version}"',
+        content,
+    )
+
+    if content == new_content:
+        print("No changes needed in engine.py")
+        return False
+
+    engine_path.write_text(new_content)
+    print(f"✓ Updated engine.py to version {new_version}")
+    return True
+
+
+def update_dockerfile(new_version: str) -> bool:
+    """Update SGL_KERNEL_VERSION in docker/Dockerfile"""
+    dockerfile_path = Path("docker/Dockerfile")
+
+    if not dockerfile_path.exists():
+        print(f"Error: {dockerfile_path} not found")
+        sys.exit(1)
+
+    content = dockerfile_path.read_text()
+
+    # Replace ARG SGL_KERNEL_VERSION=x.x.x with new version
+    new_content = re.sub(
+        r"^(ARG\s+SGL_KERNEL_VERSION=)(.+)$",
+        rf"\g<1>{new_version}",
+        content,
+        flags=re.MULTILINE,
+    )
+
+    if content == new_content:
+        print("No changes needed in Dockerfile")
+        return False
+
+    dockerfile_path.write_text(new_content)
+    print(f"✓ Updated Dockerfile to version {new_version}")
+    return True
+
+
+def main():
+    kernel_version = get_kernel_version_from_source()
+    print(f"Bumping sgl-kernel version to: {kernel_version}\n")
+
+    updated_files = []
+
+    if update_python_pyproject(kernel_version):
+        updated_files.append("python/pyproject.toml")
+
+    if update_engine_py(kernel_version):
+        updated_files.append("python/sglang/srt/entrypoints/engine.py")
+
+    if update_dockerfile(kernel_version):
+        updated_files.append("docker/Dockerfile")
+
+    print()
+    if updated_files:
+        print(f"✓ Successfully updated {len(updated_files)} file(s):")
+        for file in updated_files:
+            print(f"  - {file}")
+    else:
+        print("✓ All files already have the correct version")
+
+
+if __name__ == "__main__":
+    main()

scripts/release/check_kernel_version_to_sglang.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Check if sgl-kernel version from sgl-kernel/pyproject.toml matches the versions
+used in SGLang files (python/pyproject.toml, engine.py, and Dockerfile).
+Sets GitHub Actions output variables to indicate if sync is needed.
+"""
+
+import os
+import re
+import sys
+from pathlib import Path
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    import tomli as tomllib  # Fallback for older Python versions
+
+
+def get_kernel_version_from_source() -> str:
+    """Extract version from sgl-kernel/pyproject.toml (line 11)"""
+    pyproject_path = Path("sgl-kernel/pyproject.toml")
+
+    if not pyproject_path.exists():
+        print(f"Error: {pyproject_path} not found")
+        sys.exit(1)
+
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    version = data.get("project", {}).get("version")
+    if not version:
+        print("Error: Could not find version in sgl-kernel/pyproject.toml")
+        sys.exit(1)
+
+    return version
+
+
+def get_kernel_version_from_python_pyproject() -> str:
+    """Extract sgl-kernel version from python/pyproject.toml"""
+    pyproject_path = Path("python/pyproject.toml")
+
+    if not pyproject_path.exists():
+        print(f"Error: {pyproject_path} not found")
+        sys.exit(1)
+
+    content = pyproject_path.read_text()
+
+    # Match "sgl-kernel==x.x.x"
+    match = re.search(r'"sgl-kernel==([^"]+)"', content)
+    if not match:
+        print("Error: Could not find sgl-kernel version in python/pyproject.toml")
+        sys.exit(1)
+
+    return match.group(1)
+
+
+def get_kernel_version_from_engine() -> str:
+    """Extract sgl-kernel version from python/sglang/srt/entrypoints/engine.py"""
+    engine_path = Path("python/sglang/srt/entrypoints/engine.py")
+
+    if not engine_path.exists():
+        print(f"Error: {engine_path} not found")
+        sys.exit(1)
+
+    content = engine_path.read_text()
+
+    # Find the assert_pkg_version call for sgl-kernel
+    # Look for the pattern: assert_pkg_version("sgl-kernel", "version", ...)
+    match = re.search(
+        r'assert_pkg_version\s*\(\s*"sgl-kernel"\s*,\s*"([^"]+)"', content
+    )
+    if not match:
+        print("Error: Could not find sgl-kernel version in engine.py")
+        sys.exit(1)
+
+    return match.group(1)
+
+
+def get_kernel_version_from_dockerfile() -> str:
+    """Extract SGL_KERNEL_VERSION from docker/Dockerfile"""
+    dockerfile_path = Path("docker/Dockerfile")
+
+    if not dockerfile_path.exists():
+        print(f"Error: {dockerfile_path} not found")
+        sys.exit(1)
+
+    content = dockerfile_path.read_text()
+
+    # Match ARG SGL_KERNEL_VERSION=x.x.x
+    match = re.search(r"^ARG\s+SGL_KERNEL_VERSION=(.+)$", content, re.MULTILINE)
+    if not match:
+        print("Error: Could not find SGL_KERNEL_VERSION in Dockerfile")
+        sys.exit(1)
+
+    return match.group(1).strip()
+
+
+def main():
+    kernel_version = get_kernel_version_from_source()
+    pyproject_version = get_kernel_version_from_python_pyproject()
+    engine_version = get_kernel_version_from_engine()
+    dockerfile_version = get_kernel_version_from_dockerfile()
+
+    print(f"Kernel version in sgl-kernel/pyproject.toml: {kernel_version}")
+    print(f"Kernel version in python/pyproject.toml: {pyproject_version}")
+    print(f"Kernel version in engine.py: {engine_version}")
+    print(f"Kernel version in Dockerfile: {dockerfile_version}")
+
+    # Check if any version differs from the source
+    needs_sync = (
+        kernel_version != pyproject_version
+        or kernel_version != engine_version
+        or kernel_version != dockerfile_version
+    )
+
+    # Set GitHub Actions output
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"needs_sync={'true' if needs_sync else 'false'}\n")
+            f.write(f"kernel_version={kernel_version}\n")
+
+    if needs_sync:
+        print(f"\n✓ Sync needed to version: {kernel_version}")
+        mismatches = []
+        if kernel_version != pyproject_version:
+            mismatches.append(
+                f"  - python/pyproject.toml: {pyproject_version} → {kernel_version}"
+            )
+        if kernel_version != engine_version:
+            mismatches.append(f"  - engine.py: {engine_version} → {kernel_version}")
+        if kernel_version != dockerfile_version:
+            mismatches.append(
+                f"  - Dockerfile: {dockerfile_version} → {kernel_version}"
+            )
+
+        print("Changes needed:")
+        for mismatch in mismatches:
+            print(mismatch)
+
+        sys.exit(0)
+    else:
+        print("\n✓ All versions are in sync, no action needed")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

scripts/release/commit_and_pr_kernel_to_sglang.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+set -e
+
+# Script to commit kernel version bump changes to SGLang and create a pull request
+# Usage: commit_and_pr_kernel_to_sglang.sh <kernel_version> <branch_name>
+#
+# Arguments:
+#   kernel_version: The kernel version being synced
+#   branch_name: The git branch name to push to
+
+KERNEL_VERSION="$1"
+BRANCH_NAME="$2"
+
+if [ -z "$KERNEL_VERSION" ] || [ -z "$BRANCH_NAME" ]; then
+    echo "Error: Missing required arguments"
+    echo "Usage: $0 <kernel_version> <branch_name>"
+    exit 1
+fi
+
+# Get changed files and format them
+echo "Getting changed files..."
+FILES_LIST=$(git diff --name-only | sed 's/^/- /')
+COMMIT_FILES=$(git diff --name-only | sed 's/^/          - /')
+
+# Commit changes
+echo "Committing changes..."
+git add -A
+git commit -m "chore: bump sgl-kernel version to ${KERNEL_VERSION} in SGLang
+
+This commit updates the sgl-kernel version across SGLang files to match
+the version defined in sgl-kernel/pyproject.toml.
+
+Files updated:
+${COMMIT_FILES}
+
+🤖 Generated with GitHub Actions"
+
+# Push changes
+echo "Pushing to ${BRANCH_NAME}..."
+git push origin "${BRANCH_NAME}"
+
+# Create pull request
+echo "Creating pull request..."
+PR_URL=$(gh pr create \
+  --title "chore: bump sgl-kernel version to ${KERNEL_VERSION}" \
+  --body "## Summary
+
+This PR bumps the \`sgl-kernel\` version to \`${KERNEL_VERSION}\` across SGLang files to match the version defined in \`sgl-kernel/pyproject.toml\`.
+
+**Kernel Version:** \`${KERNEL_VERSION}\`
+
+## Files Updated
+${FILES_LIST}
+
+## Context
+
+The sgl-kernel version in \`sgl-kernel/pyproject.toml\` has been updated. This PR ensures that all SGLang files referencing the kernel version are updated accordingly:
+- \`python/pyproject.toml\` - dependency specification
+- \`python/sglang/srt/entrypoints/engine.py\` - version check
+- \`docker/Dockerfile\` - Docker build argument
+
+🤖 Generated with GitHub Actions" \
+  --base main \
+  --head "${BRANCH_NAME}")
+
+echo "✓ Pull request created successfully"
+
+# Add GitHub Actions job summary
+if [ -n "$GITHUB_STEP_SUMMARY" ]; then
+  cat >> "$GITHUB_STEP_SUMMARY" <<EOF
+## ✅ Kernel Version Bump Complete
+
+**Kernel Version:** \`${KERNEL_VERSION}\`
+
+### 📝 Pull Request Created
+${PR_URL}
+
+### 📦 Files Updated
+${FILES_LIST}
+EOF
+fi