Auto updated submodule references

.github/workflows/create-release-from-commit.yaml

@@ -0,0 +1,64 @@
+name: "Create Release Tag"
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'The new release tag to create (e.g., v3.8.1)'
+        required: true
+        type: string
+      commit_sha:
+        description: 'The short commit SHA from the calcom submodule to use for this release'
+        required: true
+        type: string
+
+jobs:
+  release:
+    name: "Tag Release"
+    runs-on: "ubuntu-latest"
+
+    steps:
+      - name: "Checkout main branch to get starting point"
+        uses: "actions/checkout@v4"
+        with:
+          token: ${{ secrets.TOKEN_GITEA }}
+          # We check out main, but will create the release commit off of it
+          # without modifying the branch itself.
+          ref: 'main' 
+          submodules: true
+
+      - name: "Create Release Commit and Tag"
+        run: |
+          # Configure git user for the commit
+          git config user.email "actions@gitea.local"
+          git config user.name "Gitea Actions"
+
+          echo "Updating submodule to commit ${{ inputs.commit_sha }}..."
+          
+          # Navigate into the submodule, fetch latest history, and check out the specific commit.
+          # This modifies the submodule's checked-out version in the working directory.
+          cd calcom
+          git fetch origin
+          git checkout ${{ inputs.commit_sha }}
+          cd ..
+
+          # Stage the change to the submodule pointer.
+          git add calcom
+
+          # Create a NEW commit. This commit is NOT on the main branch.
+          # It's a "dangling" commit that only HEAD is pointing to at this moment.
+          # The parent of this new commit is the latest commit from 'main'.
+          git commit -m "release: Version ${{ inputs.version }} with calcom at ${{ inputs.commit_sha }}"
+
+          # Get the full SHA of the new commit we just created.
+          NEW_COMMIT_SHA=$(git rev-parse HEAD)
+          echo "Created new release commit: $NEW_COMMIT_SHA"
+
+          echo "Creating and pushing tag ${{ inputs.version }}..."
+          
+          # Create an annotated tag pointing directly at our new, branchless commit.
+          git tag -a "${{ inputs.version }}" -m "Release ${{ inputs.version }}" $NEW_COMMIT_SHA
+          
+          # Push ONLY the new tag to the repository. Git will automatically send
+          # the required commit object ($NEW_COMMIT_SHA) along with the tag.
+          git push origin "${{ inputs.version }}"

.github/workflows/create-release.yaml

@@ -1,60 +1,77 @@
-name: "Create Release"
+name: "Create Gitea Release"
 
-on: # yamllint disable-line rule:truthy
+# This workflow is triggered manually from the Gitea Actions UI
+on:
   workflow_dispatch:
     inputs:
       RELEASE_TAG:
-        description: 'v{Major}.{Minor}.{Patch}'  
+        description: 'The release tag to create, formatted as v{Major}.{Minor}.{Patch}'
+        required: true
 
 jobs:
   release:
     name: "Release"
-    permissions:
-      contents: write
     runs-on: "ubuntu-latest"
 
     steps:
-      
+      # Step 1: Check out the repository source code and its submodules.
+      # The TOKEN_GITEA is used here to grant permission for the later 'git push'.
       - name: Checkout source
-        uses: actions/checkout@v3
+        uses: "actions/checkout@v4"
         with:
-          token: ${{ secrets.ACTIONS_ACCESS_TOKEN }}
+          token: ${{ secrets.TOKEN_GITEA }}
           submodules: true
 
-      - name: Create branch and tag submodule
+      # Step 2: Create a new release branch, update the submodule to the specified tag,
+      # and push the new branch to the Gitea repository.
+      - name: Create Branch and Update Submodule
         run: |
-          git config user.email "actions@github.com"
+          # Configure git user for the commit
-          git config user.name "actions-user"
+          git config user.email "actions@gitea.local"
-          git submodule update --init --remote
+          git config user.name "Gitea Actions"
+
+          # Create the new release branch
           git checkout -b 'release-${{ inputs.RELEASE_TAG }}'
+
+          # Enter the submodule directory, fetch the latest tags, and check out the correct one.
+          # This points the submodule to the specific commit associated with the release tag.
           (cd calcom && git fetch --tags origin && git checkout 'refs/tags/${{ inputs.RELEASE_TAG }}')
+
+          # Stage and commit the change to the submodule pointer
           git add calcom
-          git commit -m "tag version Cal.com version ${{ inputs.RELEASE_TAG }}"
+          git commit -m "Update submodule to Cal.com version ${{ inputs.RELEASE_TAG }}"
+
+          # Push the newly created release branch to the remote Gitea repository
           git push origin 'release-${{ inputs.RELEASE_TAG }}'
 
-      # note: instead of secrets.GITHUB_TOKEN here, we need to use a PAT 
+      # Step 3: Call the Gitea API to create the official release object.
-      #       so that the release creation triggers the image build workflow
+      # This uses the same API token to authorize the action.
-      - name: "Create release"
+      - name: "Create Gitea Release"
-        uses: "actions/github-script@v6"
+        env:
-        with:
+          GITEA_TOKEN: ${{ secrets.TOKEN_GITEA }}
-          github-token: "${{ secrets.ACTIONS_ACCESS_TOKEN }}"
+          GITEA_API_URL: https://git.nethery.dev/api/v1
-          script: |
+          OWNER: ${{ gitea.repository_owner }}
-            const isPreRelease = '${{ inputs.RELEASE_TAG }}'.includes('-rc'); 
+          REPO: ${{ gitea.repository_name }}
-            try {
+        run: |
-              const response = await github.rest.repos.createRelease({
+          # Determine if the tag indicates a pre-release
-                draft: false,
+          is_prerelease=false
-                generate_release_notes: true,
+          if [[ "${{ inputs.RELEASE_TAG }}" == *"-rc"* || "${{ inputs.RELEASE_TAG }}" == *"-beta"* ]]; then
-                body: 'For Cal.com release details, see: https://github.com/calcom/cal.com/releases/tag/${{ inputs.RELEASE_TAG }}',
+            is_prerelease=true
-                name: '${{ inputs.RELEASE_TAG }}',
+          fi
-                target_commitish: 'release-${{ inputs.RELEASE_TAG }}',
-                owner: context.repo.owner,
-                prerelease: isPreRelease,
-                repo: context.repo.repo,
-                tag_name: '${{ inputs.RELEASE_TAG }}',
-              });
 
-              core.exportVariable('RELEASE_ID', response.data.id);
+          echo "Creating release ${{ inputs.RELEASE_TAG }}..."
-              core.exportVariable('RELEASE_UPLOAD_URL', response.data.upload_url);
+          echo "Is prerelease: $is_prerelease"
-            } catch (error) {
+
-              core.setFailed(error.message);
+          # Use curl to send a POST request to the Gitea API's 'create release' endpoint
-            }
+          curl --fail --silent --show-error -L -X POST \
+            -H "accept: application/json" \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/json" \
+            "${GITEA_API_URL}/repos/${OWNER}/${REPO}/releases" \
+            -d '{
+              "tag_name": "${{ inputs.RELEASE_TAG }}",
+              "target_commitish": "release-${{ inputs.RELEASE_TAG }}",
+              "name": "${{ inputs.RELEASE_TAG }}",
+              "body": "For Cal.com release details, see: https://github.com/calcom/cal.com/releases/tag/${{ inputs.RELEASE_TAG }}",
+              "prerelease": '${is_prerelease}'
+            }'

.github/workflows/docker-build-push-dockerhub.yml

@@ -61,15 +61,11 @@ jobs:
         run: |
           git submodule update --init
 
-      # - name: Log in to the Docker Hub registry
+      - name: Log in to the Docker Hub registry
-      #   uses: docker/login-action@v3
+        uses: docker/login-action@v3
-      #   with:
+        with:
-      #     # Username used to log against the Docker registry
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
-      #     username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_TOKEN }}
-      #     # Password or personal access token used to log against the Docker registry
-      #     password: ${{ secrets.DOCKER_HUB_TOKEN }}
-      #     # Log out from the Docker registry at the end of a job
-      #     logout: true # optional, default is true
 
       - name: Log in to the Github Container registry
         uses: docker/login-action@v3
@@ -84,7 +80,7 @@ jobs:
         with:
           images: |
             ghcr.io/nnethery/cal.com
-          # Add flavor latest only on full releases, not on pre-releases
+            nnethery/cal.com
           flavor: |
             latest=${{ !github.event.release.prerelease }}