ci: improve release workflow use rustup, tighten cargo cache, and publish via github-script

Author: theg1239

.github/workflows/release.yml

@@ -46,16 +46,20 @@ jobs:
           bun-version: latest
 
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
+        shell: bash
+        run: |
+          rustup toolchain install stable --profile minimal
+          rustup component add --toolchain stable rustfmt clippy
+          rustup default stable
 
       - name: Cache Rust
         uses: actions/cache@v4
         with:
           path: |
             ~/.cargo/registry
             ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+            apps/desktop/src-tauri/target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('apps/desktop/src-tauri/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo-
 
       - name: Install Linux system deps (Tauri)
@@ -143,14 +147,127 @@ jobs:
         with:
           path: dist-artifacts
 
-      - name: Release
-        uses: softprops/action-gh-release@v2
+      - name: Set release metadata
+        id: release_meta
+        env:
+          VERSION: ${{ steps.ver.outputs.version }}
+          PRERELEASE_INPUT: ${{ inputs.prerelease || 'false' }}
+        run: |
+          version="$VERSION"
+          prerelease_input="$PRERELEASE_INPUT"
+          is_prerelease=false
+          if [ "$prerelease_input" = "true" ]; then
+            is_prerelease=true
+          elif [[ "$version" == *"-rc"* ]]; then
+            is_prerelease=true
+          fi
+          echo "prerelease=$is_prerelease" >> "$GITHUB_OUTPUT"
+
+      - name: Publish release
+        id: publish_release
+        uses: actions/github-script@v7
         with:
-          tag_name: ${{ steps.ver.outputs.version }}
-          name: Open With Browser ${{ steps.ver.outputs.version }}
-          prerelease: ${{ github.event.inputs.prerelease == 'true' || contains(steps.ver.outputs.version, '-rc') }}
-          draft: false
-          generate_release_notes: true
-          files: |
-            dist-artifacts/**
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const fs = require('fs');
+            const path = require('path');
+
+            const version = process.env.RELEASE_VERSION;
+            if (!version) {
+              core.setFailed('RELEASE_VERSION not provided');
+              return;
+            }
+
+            const artifactsDir = process.env.ARTIFACTS_DIR;
+            if (!artifactsDir || !fs.existsSync(artifactsDir)) {
+              core.warning(`Artifacts directory "${artifactsDir}" not found, skipping asset upload.`);
+              return;
+            }
+
+            const walk = (dir) => {
+              const entries = fs.readdirSync(dir, { withFileTypes: true });
+              return entries.flatMap((entry) => {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                  return walk(fullPath);
+                }
+                if (entry.isFile()) {
+                  return [fullPath];
+                }
+                return [];
+              });
+            };
+
+            const files = walk(artifactsDir);
+            if (files.length === 0) {
+              core.warning(`No files found under "${artifactsDir}" to upload.`);
+              return;
+            }
+
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const tagName = version;
+            const releaseName = `Open With Browser ${version}`;
+            const prerelease = process.env.PRERELEASE_FLAG === 'true';
+
+            let release;
+            try {
+              const existing = await github.rest.repos.getReleaseByTag({ owner, repo, tag: tagName });
+              release = existing.data;
+              core.info(`Found existing release for ${tagName}, reusing it.`);
+            } catch (error) {
+              if (error.status === 404) {
+                core.info(`Creating new release for ${tagName}.`);
+                const created = await github.rest.repos.createRelease({
+                  owner,
+                  repo,
+                  tag_name: tagName,
+                  name: releaseName,
+                  draft: false,
+                  prerelease,
+                  generate_release_notes: true,
+                });
+                release = created.data;
+              } else {
+                throw error;
+              }
+            }
+
+            if (release.assets && release.assets.length > 0) {
+              core.info(`Removing ${release.assets.length} existing asset(s).`);
+              for (const asset of release.assets) {
+                await github.rest.repos.deleteReleaseAsset({
+                  owner,
+                  repo,
+                  asset_id: asset.id,
+                });
+              }
+            }
+
+            for (const file of files) {
+              const stats = fs.statSync(file);
+              if (!stats.isFile()) {
+                continue;
+              }
+              const relativePath = path.relative(artifactsDir, file).replace(/\\/g, '/');
+              const assetName = relativePath.replace(/\//g, '-');
+              core.info(`Uploading ${assetName}`);
+              await github.rest.repos.uploadReleaseAsset({
+                owner,
+                repo,
+                release_id: release.id,
+                name: assetName,
+                headers: {
+                  'content-type': 'application/octet-stream',
+                  'content-length': stats.size,
+                },
+                data: fs.readFileSync(file),
+              });
+            }
+
+            core.setOutput('release_url', release.html_url);
+        env:
+          RELEASE_VERSION: ${{ steps.ver.outputs.version }}
+          PRERELEASE_FLAG: ${{ steps.release_meta.outputs.prerelease }}
+          ARTIFACTS_DIR: dist-artifacts
     if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'