name: Release

on:
  push:
    tags: ['v*']
  workflow_dispatch:

permissions:
  contents: write
  packages: write

concurrency:
  group: release-${{ github.ref }}
  cancel-in-progress: false

jobs:
  verify:
    name: Verify
    runs-on: ubuntu-latest
    timeout-minutes: 20

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - name: Setup Node.js
        uses: actions/setup-node@v7
        with:
          node-version: 25
          cache: npm

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

      - name: Build
        run: npm run build

      - name: Upload built dist
        uses: actions/upload-artifact@v7
        with:
          name: metapi-dist-${{ github.sha }}
          path: dist
          if-no-files-found: error

  build-packages:
    name: Build Desktop Package (${{ matrix.platform }})
    needs: verify
    runs-on: ${{ matrix.runner }}
    timeout-minutes: 60
    strategy:
      fail-fast: false
      matrix:
        include:
          - platform: linux
            runner: ubuntu-latest
            artifactLabel: linux-x64
          - platform: windows
            runner: windows-latest
            artifactLabel: windows-x64
          - platform: mac-arm64
            runner: macos-15
            artifactLabel: mac-arm64
            packageCommand: npm run package:desktop -- --mac --arm64
            expectedMacArch: arm64
          - platform: mac-x64
            runner: macos-15-intel
            artifactLabel: mac-x64
            packageCommand: npm run package:desktop:mac:intel
            expectedMacArch: x64

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - name: Setup Node.js
        uses: actions/setup-node@v7
        with:
          node-version: 25
          cache: npm

      - name: Restore Electron cache (Windows)
        if: runner.os == 'Windows'
        uses: actions/cache@v6
        with:
          path: |
            ${{ runner.temp }}/.cache/electron
            ${{ runner.temp }}/.cache/electron-builder
            ${{ env.LOCALAPPDATA }}\electron\Cache
            ${{ env.LOCALAPPDATA }}\electron-builder\Cache
          key: electron-cache-${{ runner.os }}-${{ hashFiles('package-lock.json', 'package.json', 'electron-builder.yml') }}
          restore-keys: |
            electron-cache-${{ runner.os }}-

      - name: Restore Electron cache (Linux)
        if: runner.os == 'Linux'
        uses: actions/cache@v6
        with:
          path: |
            ${{ runner.temp }}/.cache/electron
            ${{ runner.temp }}/.cache/electron-builder
            ${{ runner.temp }}/.cache/appimage-tools
            ~/.cache/electron
            ~/.cache/electron-builder
          key: electron-cache-${{ runner.os }}-${{ hashFiles('package-lock.json', 'package.json', 'electron-builder.yml') }}
          restore-keys: |
            electron-cache-${{ runner.os }}-

      - name: Restore Electron cache (macOS)
        if: runner.os == 'macOS'
        uses: actions/cache@v6
        with:
          path: |
            ${{ runner.temp }}/.cache/electron
            ${{ runner.temp }}/.cache/electron-builder
            ~/Library/Caches/electron
            ~/Library/Caches/electron-builder
          key: electron-cache-${{ runner.os }}-${{ hashFiles('package-lock.json', 'package.json', 'electron-builder.yml') }}
          restore-keys: |
            electron-cache-${{ runner.os }}-

      - name: Install dependencies
        run: npm ci

      - name: Install Linux packaging dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
          sudo apt-get install --no-install-recommends -y rpm

      - name: Download built dist
        uses: actions/download-artifact@v8
        with:
          name: metapi-dist-${{ github.sha }}
          path: dist

      - name: Build desktop artifacts (Windows)
        if: runner.os == 'Windows'
        shell: pwsh
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          npm_config_cache: ${{ runner.temp }}/.npm
          ELECTRON_CACHE: ${{ runner.temp }}/.cache/electron
          ELECTRON_BUILDER_CACHE: ${{ runner.temp }}/.cache/electron-builder
          ELECTRON_BUILDER_BINARIES_MIRROR: https://github.com/electron-userland/electron-builder-binaries/releases/download/
          npm_config_electron_builder_binaries_mirror: https://github.com/electron-userland/electron-builder-binaries/releases/download/
          WIN_CSC_LINK_INPUT: ${{ secrets.CSC_LINK }}
          WIN_CSC_KEY_PASSWORD_INPUT: ${{ secrets.CSC_KEY_PASSWORD }}
        run: |
          if ($env:WIN_CSC_LINK_INPUT) { $env:WIN_CSC_LINK = $env:WIN_CSC_LINK_INPUT }
          if ($env:WIN_CSC_KEY_PASSWORD_INPUT) { $env:WIN_CSC_KEY_PASSWORD = $env:WIN_CSC_KEY_PASSWORD_INPUT }
          for ($attempt = 1; $attempt -le 2; $attempt++) {
            Write-Host "Desktop build attempt $attempt/2"
            npm run package:desktop
            if ($LASTEXITCODE -eq 0) {
              break
            }
            if ($attempt -eq 2) {
              exit $LASTEXITCODE
            }
            Start-Sleep -Seconds 90
          }

      - name: Smoke test packaged native modules (Windows)
        if: runner.os == 'Windows'
        shell: pwsh
        env:
          ELECTRON_RUN_AS_NODE: 1
        run: |
          $appRoot = Join-Path $PWD 'release\win-unpacked\resources\app'
          $exePath = Join-Path $PWD 'release\win-unpacked\Metapi.exe'
          Push-Location $appRoot
          try {
            & $exePath -e "require('./node_modules/better-sqlite3'); console.log('better-sqlite3 ok')"
            if ($LASTEXITCODE -ne 0) {
              exit $LASTEXITCODE
            }
          } finally {
            Pop-Location
          }

      - name: Build desktop artifacts (Linux)
        if: runner.os == 'Linux'
        shell: bash
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          npm_config_cache: ${{ runner.temp }}/.npm
          ELECTRON_CACHE: ${{ runner.temp }}/.cache/electron
          ELECTRON_BUILDER_CACHE: ${{ runner.temp }}/.cache/electron-builder
          ELECTRON_BUILDER_BINARIES_MIRROR: https://github.com/electron-userland/electron-builder-binaries/releases/download/
          npm_config_electron_builder_binaries_mirror: https://github.com/electron-userland/electron-builder-binaries/releases/download/
        run: |
          set -euo pipefail
          for attempt in 1 2; do
            echo "Desktop build attempt ${attempt}/2"
            if npm run package:desktop; then
              break
            fi
            if [ "$attempt" -eq 2 ]; then
              exit 1
            fi
            sleep 90
          done

      - name: Build desktop artifacts (macOS)
        if: startsWith(matrix.platform, 'mac-')
        shell: bash
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          npm_config_cache: ${{ runner.temp }}/.npm
          ELECTRON_CACHE: ${{ runner.temp }}/.cache/electron
          ELECTRON_BUILDER_CACHE: ${{ runner.temp }}/.cache/electron-builder
          ELECTRON_BUILDER_BINARIES_MIRROR: https://github.com/electron-userland/electron-builder-binaries/releases/download/
          npm_config_electron_builder_binaries_mirror: https://github.com/electron-userland/electron-builder-binaries/releases/download/
          APPLE_ID_INPUT: ${{ secrets.APPLE_ID }}
          APPLE_APP_SPECIFIC_PASSWORD_INPUT: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
          APPLE_TEAM_ID_INPUT: ${{ secrets.APPLE_TEAM_ID }}
          PACKAGE_COMMAND: ${{ matrix.packageCommand }}
        run: |
          set -euo pipefail
          if [ -n "${APPLE_ID_INPUT:-}" ]; then export APPLE_ID="$APPLE_ID_INPUT"; fi
          if [ -n "${APPLE_APP_SPECIFIC_PASSWORD_INPUT:-}" ]; then export APPLE_APP_SPECIFIC_PASSWORD="$APPLE_APP_SPECIFIC_PASSWORD_INPUT"; fi
          if [ -n "${APPLE_TEAM_ID_INPUT:-}" ]; then export APPLE_TEAM_ID="$APPLE_TEAM_ID_INPUT"; fi
          for attempt in 1 2; do
            echo "Desktop build (${PACKAGE_COMMAND}) attempt ${attempt}/2"
            if eval "${PACKAGE_COMMAND}"; then
              break
            fi
            if [ "$attempt" -eq 2 ]; then
              exit 1
            fi
            sleep 90
          done

      - name: Verify packaged macOS architecture
        if: startsWith(matrix.platform, 'mac-')
        shell: bash
        env:
          expectedMacArch: ${{ matrix.expectedMacArch }}
        run: |
          node scripts/desktop/verifyMacArchitecture.mjs --release-dir release --expected-arch "$expectedMacArch"

      - name: Upload desktop package
        uses: actions/upload-artifact@v7
        with:
          name: metapi-desktop-${{ github.run_id }}-${{ matrix.artifactLabel }}
          path: |
            release/*.exe
            release/*.dmg
            release/*.zip
            release/*.AppImage
            release/*.deb
            release/*.rpm
            release/*.blockmap
            release/latest*.yml
            release/latest*.json
            release/builder-debug.yml
          if-no-files-found: error

  build-server-bundle:
    name: Build Server Bundle (${{ matrix.arch }})
    needs: verify
    runs-on: ${{ matrix.runner }}
    timeout-minutes: 45
    strategy:
      fail-fast: false
      matrix:
        include:
          - arch: amd64
            runner: ubuntu-latest
          - arch: arm64
            runner: ubuntu-24.04-arm

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - name: Setup Node.js
        uses: actions/setup-node@v7
        with:
          node-version: 25
          cache: npm

      - name: Install dependencies
        env:
          ELECTRON_SKIP_BINARY_DOWNLOAD: '1'
        run: npm ci --no-audit --no-fund

      - name: Rebuild native modules for target architecture
        run: npm rebuild better-sqlite3 --no-audit --no-fund

      - name: Build web and server
        run: npm run build:web && npm run build:server

      - name: Build server release bundle
        run: node scripts/release/build-server-bundle.mjs --version "$(node -p \"require('./package.json').version\")" --arch "${{ matrix.arch }}" --out-dir release-server

      - name: Smoke-test server bundle and stable runner
        shell: bash
        env:
          EXPECTED_ARCH: ${{ matrix.arch }}
        run: |
          set -euo pipefail
          archive="$(find release-server -maxdepth 1 -type f -name "metapi-server-v*-linux-${EXPECTED_ARCH}.tar.gz" -print -quit)"
          if [ -z "$archive" ]; then
            echo "Server bundle for ${EXPECTED_ARCH} was not created" >&2
            exit 1
          fi

          archive_name="$(basename "$archive")"
          (cd release-server && sha256sum -c "${archive_name}.sha256")

          smoke_root="$(mktemp -d)"
          runner_pid=""
          cleanup() {
            if [ -n "$runner_pid" ] && kill -0 "$runner_pid" 2>/dev/null; then
              kill -TERM "$runner_pid" 2>/dev/null || true
              wait "$runner_pid" 2>/dev/null || true
            fi
            rm -rf "$smoke_root"
          }
          trap cleanup EXIT

          mkdir -p "$smoke_root/bundle" "$smoke_root/data" "$smoke_root/runtime"
          tar -xzf "$archive" -C "$smoke_root/bundle"
          BUNDLE_DIR="$smoke_root/bundle" EXPECTED_ARCH="$EXPECTED_ARCH" ARCHIVE_NAME="$archive_name" node --input-type=module <<'NODE'
          import { createRequire } from 'node:module';
          import { existsSync, readFileSync } from 'node:fs';
          import { join } from 'node:path';
          import { hashPayload } from './scripts/release/build-server-bundle.mjs';

          const bundle = process.env.BUNDLE_DIR;
          const manifest = JSON.parse(readFileSync(join(bundle, 'release.json'), 'utf8'));
          const nodeMajor = Number.parseInt(process.versions.node.split('.')[0] || '0', 10);
          if (manifest.schemaVersion !== 1 || manifest.platform !== 'linux') throw new Error('invalid server bundle manifest');
          if (manifest.arch !== process.env.EXPECTED_ARCH) throw new Error(`expected ${process.env.EXPECTED_ARCH}, got ${manifest.arch}`);
          if (manifest.nodeMajor !== nodeMajor || nodeMajor !== 25) throw new Error(`server bundle requires Node ${manifest.nodeMajor}, running ${nodeMajor}`);
          if (manifest.artifactName !== process.env.ARCHIVE_NAME) throw new Error('server bundle artifact name mismatch');
          if (manifest.artifactSha256 !== hashPayload(bundle)) throw new Error('server bundle payload checksum mismatch');
          for (const path of [manifest.entrypoint, manifest.migrationEntrypoint]) {
            if (!path || !existsSync(join(bundle, path))) throw new Error(`server bundle entrypoint is missing: ${path}`);
          }

          const require = createRequire(join(bundle, 'package.json'));
          const Database = require('better-sqlite3');
          const database = new Database(':memory:');
          database.prepare('select 1').get();
          database.close();
          NODE

          port="$(node -e "import('get-port').then(async ({default: getPort}) => console.log(await getPort()))")"
          version="$(node -p "require('./package.json').version")"
          UPDATE_CENTER_RUNTIME_DIR="$smoke_root/runtime" \
          UPDATE_CENTER_RUNTIME_PERSISTENT=true \
          METAPI_BOOTSTRAP_DIR="$smoke_root/bundle" \
          DATA_DIR="$smoke_root/data" \
          DB_TYPE=sqlite \
          AUTH_TOKEN=release-smoke-admin \
          PROXY_TOKEN=release-smoke-proxy \
          HOST=127.0.0.1 \
          PORT="$port" \
          node scripts/runtime/docker-runner.mjs >"$smoke_root/runner.log" 2>&1 &
          runner_pid=$!

          PORT="$port" EXPECTED_VERSION="$version" node --input-type=module <<'NODE'
          const deadline = Date.now() + 65_000;
          let lastError = new Error('health check did not run');
          while (Date.now() < deadline) {
            try {
              const response = await fetch(`http://127.0.0.1:${process.env.PORT}/healthz`, {
                signal: AbortSignal.timeout(2_000),
              });
              const payload = await response.json();
              if (response.ok && payload.ready === true && payload.version === process.env.EXPECTED_VERSION) process.exit(0);
              lastError = new Error(`unexpected health payload: ${JSON.stringify(payload)}`);
            } catch (error) {
              lastError = error;
            }
            await new Promise((resolve) => setTimeout(resolve, 500));
          }
          throw lastError;
          NODE

          RUNTIME_DIR="$smoke_root/runtime" EXPECTED_VERSION="$version" node --input-type=module <<'NODE'
          import { readFileSync, readlinkSync } from 'node:fs';
          import { join } from 'node:path';
          const runtime = process.env.RUNTIME_DIR;
          const state = JSON.parse(readFileSync(join(runtime, 'state.json'), 'utf8'));
          if (state.schemaVersion !== 1 || state.currentVersion !== process.env.EXPECTED_VERSION || state.updateState !== 'healthy') {
            throw new Error(`unexpected runner state: ${JSON.stringify(state)}`);
          }
          if (readlinkSync(join(runtime, 'current')) !== `releases/${process.env.EXPECTED_VERSION}`) {
            throw new Error('runner current pointer mismatch');
          }
          NODE

          kill -TERM "$runner_pid"
          wait "$runner_pid"
          runner_pid=""

      - name: Upload server bundle
        uses: actions/upload-artifact@v7
        with:
          name: metapi-server-${{ matrix.arch }}
          path: release-server/*.tar.gz
          if-no-files-found: error

  publish-release:
    name: Publish GitHub Release
    needs: [build-packages, build-server-bundle]
    runs-on: ubuntu-latest
    timeout-minutes: 15
    if: startsWith(github.ref, 'refs/tags/')

    steps:
      - name: Download package artifacts
        uses: actions/download-artifact@v8
        with:
          path: release-assets
          merge-multiple: true

      - name: Download server bundle artifacts
        uses: actions/download-artifact@v8
        with:
          pattern: metapi-server-*
          path: server-assets
          merge-multiple: true

      - name: Build combined server checksums
        shell: bash
        run: |
          set -euo pipefail
          (
            cd server-assets
            sha256sum -- *.tar.gz | sort
          ) > server-assets/checksums.txt

      - name: Show release files
        run: |
          ls -la release-assets
          ls -la server-assets

      - name: Upload Release Assets
        uses: softprops/action-gh-release@v3
        with:
          tag_name: ${{ github.ref_name }}
          generate_release_notes: true
          files: |
            release-assets/*
            server-assets/*.tar.gz
            server-assets/checksums.txt

  publish-docker-arch:
    name: Publish Docker Image (${{ matrix.arch }})
    needs: build-packages
    runs-on: ${{ matrix.runner }}
    timeout-minutes: 45
    if: startsWith(github.ref, 'refs/tags/')
    env:
      DOCKERHUB_IMAGE: ${{ secrets.DOCKERHUB_USERNAME }}/metapi
    strategy:
      fail-fast: false
      matrix:
        include:
          - arch: amd64
            platform: linux/amd64
            runner: ubuntu-latest
          - arch: arm64
            platform: linux/arm64
            runner: ubuntu-24.04-arm

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - name: Ensure Docker Hub secrets are configured
        run: |
          if [ -z "${{ secrets.DOCKERHUB_USERNAME }}" ] || [ -z "${{ secrets.DOCKERHUB_TOKEN }}" ]; then
            echo "Missing Docker Hub secrets: DOCKERHUB_USERNAME / DOCKERHUB_TOKEN"
            exit 1
          fi

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v4

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Login to Docker Hub
        uses: docker/login-action@v4
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Docker metadata
        id: meta
        uses: docker/metadata-action@v6
        with:
          images: |
            ${{ env.DOCKERHUB_IMAGE }}
            ghcr.io/${{ github.repository }}
          tags: |
            type=ref,event=tag
            type=raw,value=latest

      - name: Add architecture suffix to tags
        id: arch-tags
        shell: bash
        run: |
          set -euo pipefail
          rm -f tags.txt
          while IFS= read -r tag; do
            [ -n "$tag" ] || continue
            echo "${tag}-${{ matrix.arch }}" >> tags.txt
          done <<< "${{ steps.meta.outputs.tags }}"
          {
            echo 'tags<<EOF'
            cat tags.txt
            echo 'EOF'
          } >> "$GITHUB_OUTPUT"

      - name: Build and push ${{ matrix.platform }} image
        uses: docker/build-push-action@v7
        with:
          context: .
          file: docker/Dockerfile
          platforms: ${{ matrix.platform }}
          push: true
          tags: ${{ steps.arch-tags.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha,scope=release-${{ matrix.arch }}
          cache-to: type=gha,mode=max,scope=release-${{ matrix.arch }}

  publish-docker:
    name: Publish Docker Manifests
    needs: publish-docker-arch
    runs-on: ubuntu-latest
    timeout-minutes: 15
    if: startsWith(github.ref, 'refs/tags/')
    env:
      DOCKERHUB_IMAGE: ${{ secrets.DOCKERHUB_USERNAME }}/metapi

    steps:
      - name: Checkout
        uses: actions/checkout@v7

      - name: Ensure Docker Hub secrets are configured
        run: |
          if [ -z "${{ secrets.DOCKERHUB_USERNAME }}" ] || [ -z "${{ secrets.DOCKERHUB_TOKEN }}" ]; then
            echo "Missing Docker Hub secrets: DOCKERHUB_USERNAME / DOCKERHUB_TOKEN"
            exit 1
          fi

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v4

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Login to Docker Hub
        uses: docker/login-action@v4
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Docker metadata
        id: meta
        uses: docker/metadata-action@v6
        with:
          images: |
            ${{ env.DOCKERHUB_IMAGE }}
            ghcr.io/${{ github.repository }}
          tags: |
            type=ref,event=tag
            type=raw,value=latest

      - name: Create multi-arch manifests
        shell: bash
        run: |
          set -euo pipefail
          while IFS= read -r tag; do
            [ -n "$tag" ] || continue
            docker buildx imagetools create \
              --tag "$tag" \
              "${tag}-amd64" \
              "${tag}-arm64"
          done <<< "${{ steps.meta.outputs.tags }}"