computer/.github/workflows/publish-computer.yml

name: Publish Computer Package

on:
  push:
    tags:
      - 'computer-v*'
  workflow_dispatch:
    inputs:
      version:
        description: 'Version to publish (without v prefix)'
        required: true
        default: '0.1.0'
  workflow_call:
    inputs:
      version:
        description: 'Version to publish'
        required: true
        type: string

# Adding permissions at workflow level
permissions:
  contents: write

jobs:
  prepare:
    runs-on: macos-latest
    outputs:
      version: ${{ steps.get-version.outputs.version }}
      pylume_version: ${{ steps.update-deps.outputs.pylume_version }}
      core_version: ${{ steps.update-deps.outputs.core_version }}
    steps:
    - uses: actions/checkout@v4
      
    - name: Determine version
      id: get-version
      run: |
        if [ "${{ github.event_name }}" == "push" ]; then
          # Extract version from tag (for package-specific tags)
          if [[ "${{ github.ref }}" =~ ^refs/tags/computer-v([0-9]+\.[0-9]+\.[0-9]+) ]]; then
            VERSION=${BASH_REMATCH[1]}
          else
            echo "Invalid tag format for computer"
            exit 1
          fi
        elif [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
          # Use version from workflow dispatch
          VERSION=${{ github.event.inputs.version }}
        else
          # Use version from workflow_call
          VERSION=${{ inputs.version }}
        fi
        echo "VERSION=$VERSION"
        echo "version=$VERSION" >> $GITHUB_OUTPUT

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.10'

    - name: Update dependencies to latest versions
      id: update-deps
      run: |
        cd libs/computer
        # Install required package for PyPI API access
        pip install requests
        
        # Create a more robust Python script for PyPI version checking
        cat > get_latest_versions.py << 'EOF'
        import requests
        import json
        import sys

        def get_package_version(package_name, fallback="0.1.0"):
            try:
                response = requests.get(f'https://pypi.org/pypi/{package_name}/json')
                print(f"API Response Status for {package_name}: {response.status_code}", file=sys.stderr)
                
                if response.status_code != 200:
                    print(f"API request failed for {package_name}, using fallback version", file=sys.stderr)
                    return fallback
                
                data = json.loads(response.text)
                
                if 'info' not in data:
                    print(f"Missing 'info' key in API response for {package_name}, using fallback version", file=sys.stderr)
                    return fallback
                    
                return data['info']['version']
            except Exception as e:
                print(f"Error fetching version for {package_name}: {str(e)}", file=sys.stderr)
                return fallback

        # Get latest versions
        print(get_package_version('pylume'))
        print(get_package_version('cua-core'))
        EOF
        
        # Execute the script to get the versions
        VERSIONS=($(python get_latest_versions.py))
        LATEST_PYLUME=${VERSIONS[0]}
        LATEST_CORE=${VERSIONS[1]}
        
        echo "Latest pylume version: $LATEST_PYLUME"
        echo "Latest cua-core version: $LATEST_CORE"
        
        # Output the versions for the next job
        echo "pylume_version=$LATEST_PYLUME" >> $GITHUB_OUTPUT
        echo "core_version=$LATEST_CORE" >> $GITHUB_OUTPUT
        
        # Determine major version for version constraint
        CORE_MAJOR=$(echo $LATEST_CORE | cut -d. -f1)
        NEXT_CORE_MAJOR=$((CORE_MAJOR + 1))
        
        # Update dependencies in pyproject.toml
        if [[ "$OSTYPE" == "darwin"* ]]; then
          # macOS version of sed needs an empty string for -i
          sed -i '' "s/\"pylume>=.*\"/\"pylume>=$LATEST_PYLUME\"/" pyproject.toml
          sed -i '' "s/\"cua-core>=.*,<.*\"/\"cua-core>=$LATEST_CORE,<$NEXT_CORE_MAJOR.0.0\"/" pyproject.toml
        else
          # Linux version
          sed -i "s/\"pylume>=.*\"/\"pylume>=$LATEST_PYLUME\"/" pyproject.toml
          sed -i "s/\"cua-core>=.*,<.*\"/\"cua-core>=$LATEST_CORE,<$NEXT_CORE_MAJOR.0.0\"/" pyproject.toml
        fi
        
        # Display the updated dependencies
        echo "Updated dependencies in pyproject.toml:"
        grep -E "pylume|cua-core" pyproject.toml

  publish:
    needs: prepare
    uses: ./.github/workflows/reusable-publish.yml
    with:
      package_name: "computer"
      package_dir: "libs/computer"
      version: ${{ needs.prepare.outputs.version }}
      is_lume_package: false
      base_package_name: "cua-computer"
      make_latest: false
    secrets:
      PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
    
  set-env-variables:
    needs: [prepare, publish]
    runs-on: macos-latest
    steps:
      - name: Set environment variables for use in other jobs
        run: |
          echo "PYLUME_VERSION=${{ needs.prepare.outputs.pylume_version }}" >> $GITHUB_ENV
          echo "CORE_VERSION=${{ needs.prepare.outputs.core_version }}" >> $GITHUB_ENV