oven-sh/bun

name: Auto Assign Types Issues

on:
  issues:
    types: [labeled]

jobs:
  auto-assign:
    runs-on: ubuntu-latest
    if: github.event.label.name == 'types'
    permissions:
      issues: write
    steps:
      - name: Assign to alii
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GH_REPO: ${{ github.repository }}
        run: |
          gh issue edit ${{ github.event.issue.number }} --add-assignee alii

name: Auto-close duplicate issues
on:
  schedule:
    - cron: "0 9 * * *"
  workflow_dispatch:

jobs:
  auto-close-duplicates:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    concurrency:
      group: auto-close-duplicates-${{ github.repository }}
      cancel-in-progress: true
    permissions:
      contents: read
      issues: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Bun
        uses: ./.github/actions/setup-bun

      - name: Auto-close duplicate issues
        run: bun run scripts/auto-close-duplicates.ts
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GITHUB_REPOSITORY: ${{ github.repository }}

name: Auto-label Claude PRs

on:
  pull_request:
    types: [opened]

jobs:
  auto-label:
    if: github.event.pull_request.user.login == 'robobun' || contains(github.event.pull_request.body, '🤖 Generated with')
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - name: Add claude label to PRs from robobun
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.addLabels({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              labels: ['claude']
            });

name: Claude Issue Dedupe
on:
  issues:
    types: [opened]
  workflow_dispatch:
    inputs:
      issue_number:
        description: 'Issue number to process for duplicate detection'
        required: true
        type: string

jobs:
  claude-dedupe-issues:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    concurrency:
      group: claude-dedupe-issues-${{ github.event.issue.number || inputs.issue_number }}
      cancel-in-progress: true
    permissions:
      contents: read
      issues: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Run Claude Code slash command
        uses: anthropics/claude-code-base-action@beta
        with:
          prompt: "/dedupe ${{ github.repository }}/issues/${{ github.event.issue.number || inputs.issue_number }}"
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          claude_args: "--model claude-sonnet-4-5-20250929"
          claude_env: |
            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

name: Claude Find Issues for PR
on:
  pull_request:
    types: [opened]
  workflow_dispatch:
    inputs:
      pr_number:
        description: 'PR number to find related issues for'
        required: true
        type: string

jobs:
  claude-find-issues:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    concurrency:
      group: claude-find-issues-${{ github.event.pull_request.number || inputs.pr_number }}
      cancel-in-progress: true
    permissions:
      contents: read
      pull-requests: write
      issues: read

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Run Claude Code slash command
        uses: anthropics/claude-code-base-action@beta
        with:
          prompt: "/find-issues ${{ github.repository }}/pull/${{ github.event.pull_request.number || inputs.pr_number }}"
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          claude_args: "--model claude-opus-4-6[1m]"
          claude_env: |
            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

name: Close stale robobun PRs
on:
  schedule:
    - cron: "30 0 * * *"
  workflow_dispatch:

jobs:
  close-stale-robobun-prs:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    permissions:
      pull-requests: write
    steps:
      - name: Close stale robobun PRs
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GH_REPO: ${{ github.repository }}
        run: |
          ninety_days_ago=$(date -u -d '90 days ago' +%Y-%m-%dT%H:%M:%SZ)

          gh pr list \
            --author robobun \
            --state open \
            --json number,updatedAt \
            --limit 1000 \
            --jq ".[] | select(.updatedAt < \"$ninety_days_ago\") | .number" |
          while read -r pr_number; do
            echo "Closing PR #$pr_number (last updated before $ninety_days_ago)"
            gh pr close "$pr_number" --comment "Closing this PR because it has been inactive for more than 90 days."
          done

name: autofix.ci

permissions:
  contents: read

on:
  workflow_call:
  workflow_dispatch:
  pull_request:
  merge_group:
env:
  BUN_VERSION: "1.3.2"
  LLVM_VERSION: "21.1.8"
  LLVM_VERSION_MAJOR: "21"

jobs:
  autofix:
    name: Format
    runs-on: ubuntu-latest
    concurrency:
      group: ${{ github.workflow }}-${{ github.ref }}
      cancel-in-progress: true
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Configure Git
        run: |
          git config --global core.autocrlf true
          git config --global core.ignorecase true
          git config --global core.precomposeUnicode true
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: ${{ env.BUN_VERSION }}
      - name: Setup Dependencies
        run: |
          bun install
          bun scripts/glob-sources.mjs
      - name: Format Code
        run: |
          # Start prettier in background with prefixed output
          echo "::group::Prettier"
          (bun run prettier 2>&1 | sed 's/^/[prettier] /' || echo "[prettier] Failed with exit code $?") &
          PRETTIER_PID=$!

          # Start clang-format installation and formatting in background with prefixed output
          echo "::group::Clang-format"
          (
            echo "[clang-format] Installing clang-format-${{ env.LLVM_VERSION_MAJOR }}..."
            wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null
            echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{ env.LLVM_VERSION_MAJOR }} main" | sudo tee /etc/apt/sources.list.d/llvm.list > /dev/null
            sudo apt-get update -qq
            sudo apt-get install -y -qq --no-install-recommends --no-install-suggests -o=Dpkg::Use-Pty=0 clang-format-${{ env.LLVM_VERSION_MAJOR }}
            echo "[clang-format] Running clang-format..."
            LLVM_VERSION_MAJOR=${{ env.LLVM_VERSION_MAJOR }} ./scripts/run-clang-format.sh format 2>&1 | sed 's/^/[clang-format] /'
          ) &
          CLANG_PID=$!

          # Setup Zig in temp directory and run zig fmt in background with prefixed output
          echo "::group::Zig fmt"
          (
            ZIG_TEMP=$(mktemp -d)
            echo "[zig] Downloading Zig (musl build)..."
            wget -q -O "$ZIG_TEMP/zig.zip" https://github.com/oven-sh/zig/releases/download/autobuild-e0b7c318f318196c5f81fdf3423816a7b5bb3112/bootstrap-x86_64-linux-musl.zip
            unzip -q -d "$ZIG_TEMP" "$ZIG_TEMP/zig.zip"
            export PATH="$ZIG_TEMP/bootstrap-x86_64-linux-musl:$PATH"
            echo "[zig] Running zig fmt..."
            zig fmt src 2>&1 | sed 's/^/[zig] /'
            ./scripts/sort-imports.ts src 2>&1 | sed 's/^/[zig] /'
            zig fmt src 2>&1 | sed 's/^/[zig] /'
            rm -rf "$ZIG_TEMP"
          ) &
          ZIG_PID=$!

          # Wait for all formatting tasks to complete
          echo ""
          echo "Running formatters in parallel..."
          FAILED=0

          if ! wait $PRETTIER_PID; then
            echo "::error::Prettier failed"
            FAILED=1
          fi
          echo "::endgroup::"

          if ! wait $CLANG_PID; then
            echo "::error::Clang-format failed"
            FAILED=1
          fi
          echo "::endgroup::"

          if ! wait $ZIG_PID; then
            echo "::error::Zig fmt failed"
            FAILED=1
          fi
          echo "::endgroup::"

          # Exit with error if any formatter failed
          if [ $FAILED -eq 1 ]; then
            echo "::error::One or more formatters failed"
            exit 1
          fi

          echo "✅ All formatters completed successfully"
      - name: Ban Words
        run: |
          bun ./test/internal/ban-words.test.ts
          git rm -f cmake/sources/*.txt || true
      - uses: autofix-ci/action@635ffb0c9798bd160680f18fd73371e355b85f27

name: Lint

on:
  pull_request:
  workflow_dispatch:

env:
  BUN_VERSION: "1.2.10"

jobs:
  lint-js:
    name: "Lint JavaScript"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: ${{ env.BUN_VERSION }}
      - name: Lint
        run: bun lint

name: Close AI Slop PRs

on:
  pull_request_target:
    types: [labeled]

jobs:
  on-slop:
    runs-on: ubuntu-latest
    if: github.event.label.name == 'slop' && github.repository == 'oven-sh/bun'
    permissions:
      issues: write
      pull-requests: write
    steps:
      - name: Comment and close PR
        uses: actions/github-script@v7
        with:
          script: |
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.pull_request.number,
              body: 'This PR has been closed because it was flagged as AI slop.\n\nMany AI-generated PRs are fine, but this one was identified as having one or more of the following issues:\n- Fails to verify the problem actually exists\n- Fails to test that the fix works\n- Makes incorrect assumptions about the codebase\n- Submits changes that are incomplete or misleading\n\nIf you believe this was done in error, please leave a comment explaining why.'
            });

            await github.rest.pulls.update({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.payload.pull_request.number,
              title: 'ai slop',
              body: 'This PR has been marked as AI slop and the description has been updated to avoid confusion or misleading reviewers.\n\nMany AI PRs are fine, but sometimes they submit a PR too early, fail to test if the problem is real, fail to reproduce the problem, or fail to test that the problem is fixed. If you think this PR is not AI slop, please leave a comment.',
              state: 'closed'
            });

name: Packages CI

on:
  push:
    branches:
      - main
    paths:
      - "packages/**"
      - .prettierrc
      - .prettierignore
      - tsconfig.json
      - oxlint.json
      - "!**/*.md"
  pull_request:
    branches:
      - main
    paths:
      - "packages/**"
      - .prettierrc
      - .prettierignore
      - tsconfig.json
      - oxlint.json
      - "!**/*.md"

env:
  BUN_VERSION: "canary"

jobs:
  bun-plugin-svelte:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: ${{ env.BUN_VERSION }}

      - name: Install dependencies
        run: |
          bun install
          pushd ./packages/bun-plugin-svelte && bun install

      - name: Lint
        run: |
          bunx oxlint@0.15 --format github --deny-warnings
          bunx prettier --config ../../.prettierrc --check .
        working-directory: ./packages/bun-plugin-svelte

      - name: Check types
        run: bun check:types
        working-directory: ./packages/bun-plugin-svelte

      - name: Test
        run: bun test
        working-directory: ./packages/bun-plugin-svelte

# TODO: Move this to bash scripts intead of Github Actions
# so it can be run from Buildkite, see: .buildkite/scripts/release.sh

name: Release
concurrency: release

env:
  BUN_VERSION: ${{ github.event.inputs.tag || github.event.release.tag_name || 'canary' }}
  BUN_LATEST: ${{ (github.event.inputs.is-latest || github.event.release.tag_name) && 'true' || 'false' }}

on:
  release:
    types:
      - published
  schedule:
    - cron: "0 14 * * *" # every day at 6am PST
  workflow_dispatch:
    inputs:
      is-latest:
        description: Is this the latest release?
        type: boolean
        default: false
      tag:
        type: string
        description: What is the release tag? (e.g. "1.0.2", "canary")
        required: true
      use-docker:
        description: Should Docker images be released?
        type: boolean
        default: false
      use-npm:
        description: Should npm packages be published?
        type: boolean
        default: false
      use-homebrew:
        description: Should binaries be released to Homebrew?
        type: boolean
        default: false
      use-s3:
        description: Should binaries be uploaded to S3?
        type: boolean
        default: false
      use-types:
        description: Should types be released to npm?
        type: boolean
        default: false
      use-definitelytyped:
        description: "Should types be PR'd to DefinitelyTyped?"
        type: boolean
        default: false

jobs:
  sign:
    name: Sign Release
    runs-on: ubuntu-latest
    if: ${{ github.repository_owner == 'oven-sh' }}
    permissions:
      contents: write
    defaults:
      run:
        working-directory: packages/bun-release
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup GPG
        uses: crazy-max/ghaction-import-gpg@v5
        with:
          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
          passphrase: ${{ secrets.GPG_PASSPHRASE }}
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: "1.2.3"
      - name: Install Dependencies
        run: bun install
      - name: Sign Release
        run: |
          echo "$GPG_PASSPHRASE" | bun upload-assets -- "${{ env.BUN_VERSION }}"
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
  npm:
    name: Release to NPM
    runs-on: ubuntu-latest
    needs: sign
    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-npm == 'true' }}
    permissions:
      contents: read
    defaults:
      run:
        working-directory: packages/bun-release
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          # To workaround issue
          ref: main
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: "1.2.3"
      - name: Install Dependencies
        run: bun install
      - name: Release
        run: bun upload-npm -- "${{ env.BUN_VERSION }}" publish
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
  npm-types:
    name: Release types to NPM
    runs-on: ubuntu-latest
    needs: sign
    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-types == 'true' }}
    permissions:
      contents: read
    defaults:
      run:
        working-directory: packages/bun-types
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: latest
      - name: Setup Bun
        if: ${{ env.BUN_VERSION != 'canary' }}
        uses: ./.github/actions/setup-bun
        with:
          bun-version: "1.2.3"
      - name: Setup Bun
        if: ${{ env.BUN_VERSION == 'canary' }}
        uses: ./.github/actions/setup-bun
        with:
          bun-version: "canary" # Must be 'canary' so tag is correct
      - name: Install Dependencies
        run: bun install
      - name: Setup Tag
        if: ${{ env.BUN_VERSION == 'canary' }}
        run: |
          VERSION=$(bun --version)
          TAG="${VERSION}-canary.$(date +'%Y%m%dT%H%M%S')"
          echo "Setup tag: ${TAG}"
          echo "TAG=${TAG}" >> ${GITHUB_ENV}
      - name: Build
        run: bun run build
        env:
          BUN_VERSION: ${{ env.TAG || env.BUN_VERSION }}
      - name: Release (canary)
        if: ${{ env.BUN_VERSION == 'canary' }}
        uses: JS-DevTools/npm-publish@v1
        with:
          package: packages/bun-types/package.json
          token: ${{ secrets.NPM_TOKEN }}
          tag: canary
      - name: Release (latest)
        if: ${{ env.BUN_LATEST == 'true' }}
        uses: JS-DevTools/npm-publish@v1
        with:
          package: packages/bun-types/package.json
          token: ${{ secrets.NPM_TOKEN }}
  definitelytyped:
    name: Make pr to DefinitelyTyped to update `bun-types` version
    runs-on: ubuntu-latest
    needs: npm-types
    if: ${{ github.event_name == 'release' || github.event.inputs.use-definitelytyped == 'true' }}
    permissions:
      contents: read
    steps:
      - name: Checkout (DefinitelyTyped)
        uses: actions/checkout@v4
        with:
          repository: DefinitelyTyped/DefinitelyTyped
      - name: Checkout (bun)
        uses: actions/checkout@v4
        with:
          path: bun
      - name: Setup Bun
        uses: ./bun/.github/actions/setup-bun
        with:
          bun-version: "1.2.0"
      - id: bun-version
        run: echo "BUN_VERSION=${BUN_VERSION#bun-v}" >> "$GITHUB_OUTPUT"
      - name: Update bun-types version in package.json
        run: |
          bun -e '
          const file = Bun.file("./types/bun/package.json");
          const json = await file.json();
          const version = "${{ steps.bun-version.outputs.BUN_VERSION }}"; 
          json.dependencies["bun-types"] = version;
          json.version = version.slice(0, version.lastIndexOf(".")) + ".9999";
          await file.write(JSON.stringify(json, null, 4) + "\n");
          '
      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v7
        if: ${{ env.BUN_LATEST == 'true' && env.BUN_VERSION != 'canary'}}
        with:
          token: ${{ secrets.ROBOBUN_TOKEN }}
          add-paths: ./types/bun/package.json
          title: "[bun] update to ${{ steps.bun-version.outputs.BUN_VERSION }}"
          commit-message: "[bun] update to ${{ steps.bun-version.outputs.BUN_VERSION }}"
          body: |
            Update `bun-types` version to ${{ steps.bun-version.outputs.BUN_VERSION }}

            https://bun.com/blog/${{ env.BUN_VERSION }}
          push-to-fork: oven-sh/DefinitelyTyped
          branch: ${{env.BUN_VERSION}}
  docker:
    name: Release to Dockerhub
    runs-on: ubuntu-latest
    needs: sign
    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-docker == 'true' }}
    permissions:
      contents: read
    strategy:
      fail-fast: false
      matrix:
        include:
          - variant: debian
            suffix: ""
          - variant: debian
            suffix: -debian
          - variant: slim
            suffix: -slim
            dir: debian-slim
          - variant: alpine
            suffix: -alpine
          - variant: distroless
            suffix: -distroless
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Docker emulator
        uses: docker/setup-qemu-action@v3
      - id: buildx
        name: Setup Docker buildx
        uses: docker/setup-buildx-action@v3
        with:
          platforms: linux/amd64,linux/arm64
      - id: metadata
        name: Setup Docker metadata
        uses: docker/metadata-action@v5
        with:
          images: oven/bun
          flavor: |
            latest=false
          tags: |
            type=raw,value=latest,enable=${{ env.BUN_LATEST == 'true' && matrix.suffix == '' }}
            type=raw,value=${{ matrix.variant }},enable=${{ env.BUN_LATEST == 'true' }}
            type=match,pattern=(bun-v)?(canary|\d+.\d+.\d+),group=2,value=${{ env.BUN_VERSION }},suffix=${{ matrix.suffix }}
            type=match,pattern=(bun-v)?(canary|\d+.\d+),group=2,value=${{ env.BUN_VERSION }},suffix=${{ matrix.suffix }}
            type=match,pattern=(bun-v)?(canary|\d+),group=2,value=${{ env.BUN_VERSION }},suffix=${{ matrix.suffix }}
      - name: Login to Docker
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Push to Docker
        uses: docker/build-push-action@v6
        with:
          context: ./dockerhub/${{ matrix.dir || matrix.variant }}
          platforms: linux/amd64,linux/arm64
          builder: ${{ steps.buildx.outputs.name }}
          push: true
          tags: ${{ steps.metadata.outputs.tags }}
          labels: ${{ steps.metadata.outputs.labels }}
          build-args: |
            BUN_VERSION=${{ env.BUN_VERSION }}
  homebrew:
    name: Release to Homebrew
    runs-on: ubuntu-latest
    needs: sign
    permissions:
      contents: read
    if: ${{ github.event_name == 'release' || github.event.inputs.use-homebrew == 'true' }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          repository: oven-sh/homebrew-bun
          token: ${{ secrets.ROBOBUN_TOKEN }}
      - id: gpg
        name: Setup GPG
        uses: crazy-max/ghaction-import-gpg@v5
        with:
          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
          passphrase: ${{ secrets.GPG_PASSPHRASE }}
      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: "2.6"
      - name: Update Tap
        run: ruby scripts/release.rb "${{ env.BUN_VERSION }}"
      - name: Commit Tap
        uses: stefanzweifel/git-auto-commit-action@v4
        with:
          commit_options: --gpg-sign=${{ steps.gpg.outputs.keyid }}
          commit_message: Release ${{ env.BUN_VERSION }}
          commit_user_name: robobun
          commit_user_email: robobun@oven.sh
          commit_author: robobun <robobun@oven.sh>
  s3:
    name: Upload to S3
    runs-on: ubuntu-latest
    needs: sign
    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-s3 == 'true' }}
    permissions:
      contents: read
    defaults:
      run:
        working-directory: packages/bun-release
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: "1.2.0"
      - name: Install Dependencies
        run: bun install
      - name: Release
        run: bun upload-s3 -- "${{ env.BUN_VERSION }}"
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY}}
          AWS_ENDPOINT: ${{ secrets.AWS_ENDPOINT }}
          AWS_BUCKET: bun

  notify-sentry:
    name: Notify Sentry
    runs-on: ubuntu-latest
    needs: s3
    steps:
      - name: Notify Sentry
        uses: getsentry/action-release@v1.7.0
        env:
          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
        with:
          ignore_missing: true
          ignore_empty: true
          version: ${{ env.BUN_VERSION }}
          environment: production

  bump:
    name: "Bump version"
    runs-on: ubuntu-latest
    if: ${{ github.event_name != 'schedule' }}
    permissions:
      pull-requests: write
      contents: write
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        if: ${{ env.BUN_LATEST == 'true' }}
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        if: ${{ env.BUN_LATEST == 'true' }}
        with:
          bun-version: "1.2.0"
      - name: Bump version
        uses: ./.github/actions/bump
        if: ${{ env.BUN_LATEST == 'true' }}
        with:
          version: ${{ env.BUN_VERSION }}
          token: ${{ github.token }}

name: Close inactive issues
on:
  # schedule:
  #   - cron: "15 * * * *"
  workflow_dispatch:

jobs:
  close-issues:
    runs-on: ubuntu-latest
    permissions:
      issues: write
      pull-requests: write
    steps:
      - uses: actions/stale@v5
        with:
          days-before-issue-close: 5
          any-of-issue-labels: "needs repro,waiting-for-author"
          exempt-issue-labels: "neverstale"
          exempt-pr-labels: "neverstale"
          remove-stale-when-updated: true
          stale-issue-label: "stale"
          stale-pr-label: "stale"
          stale-issue-message: "This issue is stale and may be closed due to inactivity. If you're still running into this, please leave a comment."
          close-issue-message: "This issue was closed because it has been inactive for 5 days since being marked as stale."
          days-before-pr-stale: 30
          days-before-pr-close: 14
          stale-pr-message: "This pull request is stale and may be closed due to inactivity."
          close-pr-message: "This pull request has been closed due to inactivity."
          repo-token: ${{ github.token }}
          operations-per-run: 1000

name: Test Bump version

on:
  workflow_dispatch:
    inputs:
      version:
        type: string
        description: What is the release tag? (e.g. "1.0.2", "canary")
        required: true

env:
  BUN_VERSION: "1.2.0"

jobs:
  bump:
    name: "Bump version"
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: write
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: ${{ env.BUN_VERSION }}
      - name: Bump version
        uses: ./.github/actions/bump
        with:
          version: ${{ inputs.version }}
          token: ${{ github.token }}

name: Update c-ares

on:
  schedule:
    - cron: "0 4 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check c-ares version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildCares.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildCares.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildCares.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/c-ares/c-ares/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi
          LATEST_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
            exit 1
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildCares.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildCares.cmake
          commit-message: "deps: update c-ares to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update c-ares to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-cares
          body: |
            ## What does this PR do?

            Updates c-ares to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/c-ares/c-ares/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-cares.yml)

name: Update hdrhistogram

on:
  schedule:
    - cron: "0 4 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check hdrhistogram version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildHdrHistogram.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildHdrHistogram.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildHdrHistogram.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/HdrHistogram/HdrHistogram_c/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/HdrHistogram/HdrHistogram_c/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi

          # Try to get commit SHA from tag object (for annotated tags)
          # If it fails, assume it's a lightweight tag pointing directly to commit
          LATEST_SHA=$(curl -sL "https://api.github.com/repos/HdrHistogram/HdrHistogram_c/git/tags/$LATEST_TAG_SHA" 2>/dev/null | jq -r '.object.sha // empty')
          if [ -z "$LATEST_SHA" ]; then
            # Lightweight tag - SHA points directly to commit
            LATEST_SHA="$LATEST_TAG_SHA"
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildHdrHistogram.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildHdrHistogram.cmake
          commit-message: "deps: update hdrhistogram to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update hdrhistogram to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-hdrhistogram
          body: |
            ## What does this PR do?

            Updates hdrhistogram to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/HdrHistogram/HdrHistogram_c/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-hdrhistogram.yml)

name: Update highway

on:
  schedule:
    - cron: "0 4 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check highway version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildHighway.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildHighway.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildHighway.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/google/highway/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          TAG_REF=$(curl -sL "https://api.github.com/repos/google/highway/git/refs/tags/$LATEST_TAG")
          if [ -z "$TAG_REF" ]; then
            echo "Error: Could not fetch tag reference for $LATEST_TAG"
            exit 1
          fi

          TAG_OBJECT_SHA=$(echo "$TAG_REF" | jq -r '.object.sha')
          TAG_OBJECT_TYPE=$(echo "$TAG_REF" | jq -r '.object.type')

          if [ -z "$TAG_OBJECT_SHA" ] || [ "$TAG_OBJECT_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi

          # Handle both lightweight tags (type: commit) and annotated tags (type: tag)
          if [ "$TAG_OBJECT_TYPE" = "commit" ]; then
            # Lightweight tag - object.sha is already the commit SHA
            LATEST_SHA="$TAG_OBJECT_SHA"
          elif [ "$TAG_OBJECT_TYPE" = "tag" ]; then
            # Annotated tag - need to fetch the tag object to get the commit SHA
            LATEST_SHA=$(curl -sL "https://api.github.com/repos/google/highway/git/tags/$TAG_OBJECT_SHA" | jq -r '.object.sha')
            if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
              echo "Error: Could not fetch commit SHA for annotated tag $LATEST_TAG @ $TAG_OBJECT_SHA"
              exit 1
            fi
          else
            echo "Error: Unexpected tag object type: $TAG_OBJECT_TYPE"
            exit 1
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildHighway.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildHighway.cmake
          commit-message: "deps: update highway to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update highway to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-highway
          body: |
            ## What does this PR do?

            Updates highway to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/google/highway/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-highway.yml)

name: Update libarchive

on:
  schedule:
    - cron: "0 3 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check libarchive version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLibArchive.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildLibArchive.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildLibArchive.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/libarchive/libarchive/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi
          LATEST_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
            exit 1
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLibArchive.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildLibArchive.cmake
          commit-message: "deps: update libarchive to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update libarchive to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-libarchive
          body: |
            ## What does this PR do?

            Updates libarchive to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/libarchive/libarchive/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libarchive.yml)

name: Update libdeflate

on:
  schedule:
    - cron: "0 2 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check libdeflate version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLibDeflate.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildLibDeflate.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildLibDeflate.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/ebiggers/libdeflate/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi
          LATEST_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
            exit 1
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLibDeflate.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildLibDeflate.cmake
          commit-message: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-libdeflate
          body: |
            ## What does this PR do?

            Updates libdeflate to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/ebiggers/libdeflate/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libdeflate.yml)

name: Update lolhtml

on:
  schedule:
    - cron: "0 1 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check lolhtml version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLolHtml.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildLolHtml.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildLolHtml.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/cloudflare/lol-html/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          # Get the commit SHA that the tag points to
          # This handles both lightweight tags (direct commit refs) and annotated tags (tag objects)
          TAG_REF_RESPONSE=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/refs/tags/$LATEST_TAG")
          LATEST_TAG_SHA=$(echo "$TAG_REF_RESPONSE" | jq -r '.object.sha')
          TAG_OBJECT_TYPE=$(echo "$TAG_REF_RESPONSE" | jq -r '.object.type')

          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi

          if [ "$TAG_OBJECT_TYPE" = "tag" ]; then
            # This is an annotated tag, we need to get the commit it points to
            LATEST_SHA=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
            if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
              echo "Error: Could not fetch commit SHA for annotated tag $LATEST_TAG @ $LATEST_TAG_SHA"
              exit 1
            fi
          else
            # This is a lightweight tag pointing directly to a commit
            LATEST_SHA="$LATEST_TAG_SHA"
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLolHtml.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildLolHtml.cmake
          commit-message: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-lolhtml
          body: |
            ## What does this PR do?

            Updates lolhtml to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/cloudflare/lol-html/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lolhtml.yml)

name: Update lshpack

on:
  schedule:
    - cron: "0 5 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check lshpack version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLshpack.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in BuildLshpack.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in BuildLshpack.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/litespeedtech/ls-hpack/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          # Get the tag reference, which contains both SHA and type
          TAG_REF=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/refs/tags/$LATEST_TAG")
          if [ -z "$TAG_REF" ]; then
            echo "Error: Could not fetch tag reference for $LATEST_TAG"
            exit 1
          fi

          LATEST_TAG_SHA=$(echo "$TAG_REF" | jq -r '.object.sha')
          TAG_TYPE=$(echo "$TAG_REF" | jq -r '.object.type')

          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi

          # If it's an annotated tag, we need to dereference it to get the commit SHA
          # If it's a lightweight tag, the SHA already points to the commit
          if [ "$TAG_TYPE" = "tag" ]; then
            LATEST_SHA=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
            if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
              echo "Error: Could not fetch commit SHA for annotated tag $LATEST_TAG"
              exit 1
            fi
          else
            # For lightweight tags, the SHA is already the commit SHA
            LATEST_SHA="$LATEST_TAG_SHA"
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLshpack.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/BuildLshpack.cmake
          commit-message: "deps: update lshpack to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update lshpack to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-lshpack
          body: |
            ## What does this PR do?

            Updates lshpack to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/litespeedtech/ls-hpack/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lshpack.yml)

name: Daily Root Certs Update Check

on:
  schedule:
    - cron: "0 0 * * *" # Runs at 00:00 UTC every day
  workflow_dispatch: # Allows manual trigger

jobs:
  check-and-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v1
        with:
          bun-version: latest

      - name: Generate root certs and capture output
        id: generate-certs
        run: |
          cd packages/bun-usockets/
          OUTPUT=$(bun generate-root-certs.mjs -v)
          echo "cert_output<<EOF" >> $GITHUB_ENV
          echo "$OUTPUT" >> $GITHUB_ENV
          echo "EOF" >> $GITHUB_ENV

      - name: Check for changes and stage files
        id: check-changes
        run: |
          if [[ -n "$(git status --porcelain)" ]]; then
            echo "Found changes, staging modified files..."
            git config --global user.name "github-actions[bot]"
            git config --global user.email "github-actions[bot]@users.noreply.github.com"
            
            # Get list of modified files and add them
            git status --porcelain | while read -r status file; do
              # Remove leading status and whitespace
              file=$(echo "$file" | sed 's/^.* //')
              echo "Adding changed file: $file"
              git add "$file"
            done
            
            echo "changes=true" >> $GITHUB_OUTPUT
            
            # Store the list of changed files
            CHANGED_FILES=$(git status --porcelain)
            echo "changed_files<<EOF" >> $GITHUB_ENV
            echo "$CHANGED_FILES" >> $GITHUB_ENV
            echo "EOF" >> $GITHUB_ENV
          else
            echo "No changes detected"
            echo "changes=false" >> $GITHUB_OUTPUT
          fi

      - name: Create Pull Request
        if: steps.check-changes.outputs.changes == 'true'
        uses: peter-evans/create-pull-request@v5
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          commit-message: "update(root_certs): Update root certificates $(date +'%Y-%m-%d')"
          title: "update(root_certs) $(date +'%Y-%m-%d')"
          body: |
            Automated root certificates update

            ${{ env.cert_output }}

            ## Changed Files:
            ```
            ${{ env.changed_files }}
            ```
          branch: certs/update-root-certs
          base: main
          delete-branch: true
          labels:
            - "automation"
            - "root-certs"

name: Update SQLite3

on:
  schedule:
    - cron: "0 6 * * 0" # Run weekly
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check SQLite version
        id: check-version
        run: |
          set -euo pipefail

          # Get current version from the header file using SQLITE_VERSION_NUMBER
          CURRENT_VERSION_NUM=$(grep -o '#define SQLITE_VERSION_NUMBER [0-9]\+' src/bun.js/bindings/sqlite/sqlite3_local.h | awk '{print $3}' | tr -d '\n\r')
          if [ -z "$CURRENT_VERSION_NUM" ]; then
            echo "Error: Could not find SQLITE_VERSION_NUMBER in sqlite3_local.h"
            exit 1
          fi

          # Convert numeric version to semantic version for display
          CURRENT_MAJOR=$((CURRENT_VERSION_NUM / 1000000))
          CURRENT_MINOR=$((($CURRENT_VERSION_NUM / 1000) % 1000))
          CURRENT_PATCH=$((CURRENT_VERSION_NUM % 1000))
          CURRENT_VERSION="$CURRENT_MAJOR.$CURRENT_MINOR.$CURRENT_PATCH"

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
          echo "current_num=$CURRENT_VERSION_NUM" >> $GITHUB_OUTPUT

          # Fetch SQLite download page
          DOWNLOAD_PAGE=$(curl -sL https://sqlite.org/download.html)
          if [ -z "$DOWNLOAD_PAGE" ]; then
            echo "Error: Failed to fetch SQLite download page"
            exit 1
          fi

          # Extract latest version and year from the amalgamation link
          LATEST_INFO=$(echo "$DOWNLOAD_PAGE" | grep -o 'sqlite-amalgamation-[0-9]\{7\}.zip' | head -n1)
          LATEST_YEAR=$(echo "$DOWNLOAD_PAGE" | grep -o '[0-9]\{4\}/sqlite-amalgamation-[0-9]\{7\}.zip' | head -n1 | cut -d'/' -f1 | tr -d '\n\r')
          LATEST_VERSION_NUM=$(echo "$LATEST_INFO" | grep -o '[0-9]\{7\}' | tr -d '\n\r')

          if [ -z "$LATEST_VERSION_NUM" ] || [ -z "$LATEST_YEAR" ]; then
            echo "Error: Could not extract latest version info"
            exit 1
          fi

          # Convert numeric version to semantic version for display
          LATEST_MAJOR=$((10#$LATEST_VERSION_NUM / 1000000))
          LATEST_MINOR=$((($LATEST_VERSION_NUM / 10000) % 100))
          LATEST_PATCH=$((10#$LATEST_VERSION_NUM % 1000))
          LATEST_VERSION="$LATEST_MAJOR.$LATEST_MINOR.$LATEST_PATCH"

          echo "latest=$LATEST_VERSION" >> $GITHUB_OUTPUT
          echo "latest_year=$LATEST_YEAR" >> $GITHUB_OUTPUT
          echo "latest_num=$LATEST_VERSION_NUM" >> $GITHUB_OUTPUT

          # Debug output
          echo "Current version: $CURRENT_VERSION ($CURRENT_VERSION_NUM)"
          echo "Latest version: $LATEST_VERSION ($LATEST_VERSION_NUM)"

      - name: Update SQLite if needed
        if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
        run: |
          ./scripts/update-sqlite-amalgamation.sh ${{ steps.check-version.outputs.latest_num }} ${{ steps.check-version.outputs.latest_year }}

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            src/bun.js/bindings/sqlite/sqlite3.c
            src/bun.js/bindings/sqlite/sqlite3_local.h
          commit-message: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
          title: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
          delete-branch: true
          branch: deps/update-sqlite
          body: |
            ## What does this PR do?

            Updates SQLite to version ${{ steps.check-version.outputs.latest }}

            Compare: https://sqlite.org/src/vdiff?from=${{ steps.check-version.outputs.current }}&to=${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-sqlite3.yml)

name: Update vendor

on:
  schedule:
    - cron: "0 4 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    strategy:
      matrix:
        package:
          - elysia

    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v2

      - name: Check version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          current=$(bun -p '(await Bun.file("test/vendor.json").json()).filter(v=>v.package===process.argv[1])[0].tag' ${{ matrix.package }})
          repository=$(bun -p '(await Bun.file("test/vendor.json").json()).filter(v=>v.package===process.argv[1])[0].repository' ${{ matrix.package }} | cut -d'/' -f4,5)

          if [ -z "$current" ]; then
            echo "Error: Could not find COMMIT line in test/vendor.json"
            exit 1
          fi

          echo "current=$current" >> $GITHUB_OUTPUT
          echo "repository=$repository" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/${repository}/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          echo "latest=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          bun -e 'await Bun.write("test/vendor.json", JSON.stringify((await Bun.file("test/vendor.json").json()).map(v=>{if(v.package===process.argv[1])v.tag=process.argv[2];return v;}), null, 2) + "\n")' ${{ matrix.package }} ${{ steps.check-version.outputs.latest }}

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            test/vendor.json
          commit-message: "deps: update ${{ matrix.package }} to ${{ steps.check-version.outputs.latest }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update ${{ matrix.package }} to ${{ steps.check-version.outputs.latest }}"
          delete-branch: true
          branch: deps/update-${{ matrix.package }}
          body: |
            ## What does this PR do?

            Updates ${{ matrix.package }} to version ${{ steps.check-version.outputs.latest }}

            Compare: https://github.com/${{ steps.check-version.outputs.repository }}/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-vendor.yml)

name: Update zstd

on:
  schedule:
    - cron: "0 1 * * 0"
  workflow_dispatch:

jobs:
  check-update:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4

      - name: Check zstd version
        id: check-version
        run: |
          set -euo pipefail

          # Extract the commit hash from the line after COMMIT
          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/CloneZstd.cmake)

          if [ -z "$CURRENT_VERSION" ]; then
            echo "Error: Could not find COMMIT line in CloneZstd.cmake"
            exit 1
          fi

          # Validate that it looks like a git hash
          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid git hash format in CloneZstd.cmake"
            echo "Found: $CURRENT_VERSION"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT

          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/facebook/zstd/releases/latest)
          if [ -z "$LATEST_RELEASE" ]; then
            echo "Error: Failed to fetch latest release from GitHub API"
            exit 1
          fi

          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
            echo "Error: Could not extract tag name from GitHub API response"
            exit 1
          fi

          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/facebook/zstd/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
            exit 1
          fi
          LATEST_SHA=$(curl -sL "https://api.github.com/repos/facebook/zstd/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
            exit 1
          fi

          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
            echo "Error: Invalid SHA format received from GitHub"
            echo "Found: $LATEST_SHA"
            echo "Expected: 40 character hexadecimal string"
            exit 1
          fi

          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT

      - name: Update version if needed
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        run: |
          set -euo pipefail
          # Handle multi-line format where COMMIT and its value are on separate lines
          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/CloneZstd.cmake

      - name: Create Pull Request
        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
        uses: peter-evans/create-pull-request@v7
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          add-paths: |
            cmake/targets/CloneZstd.cmake
          commit-message: "deps: update zstd to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
          title: "deps: update zstd to ${{ steps.check-version.outputs.tag }}"
          delete-branch: true
          branch: deps/update-zstd
          body: |
            ## What does this PR do?

            Updates zstd to version ${{ steps.check-version.outputs.tag }}

            Compare: https://github.com/facebook/zstd/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}

            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-zstd.yml)

name: VSCode Extension Publish
on:
  workflow_dispatch:
    inputs:
      version:
        description: "Version to publish (e.g. 0.0.25) - Check the marketplace for the latest version"
        required: true
        type: string

jobs:
  publish:
    name: "Publish to VS Code Marketplace"
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Bun
        uses: ./.github/actions/setup-bun
        with:
          bun-version: "1.2.18"

      - name: Install dependencies (root)
        run: bun install

      - name: Install dependencies
        run: bun install
        working-directory: packages/bun-vscode

      - name: Set Version
        run: bun pm version ${{ github.event.inputs.version }} --no-git-tag-version --allow-same-version
        working-directory: packages/bun-vscode

      - name: Build (inspector protocol)
        run: bun install && bun run build
        working-directory: packages/bun-inspector-protocol

      - name: Build (vscode extension)
        run: bun run build
        working-directory: packages/bun-vscode

      - name: Publish
        if: success()
        run: bunx vsce publish
        env:
          VSCE_PAT: ${{ secrets.VSCODE_EXTENSION }}
        working-directory: packages/bun-vscode/extension

      - uses: actions/upload-artifact@v4
        with:
          name: bun-vscode-${{ github.event.inputs.version }}.vsix
          path: packages/bun-vscode/extension/bun-vscode-${{ github.event.inputs.version }}.vsix