climaybe 3.1.4 → 3.3.0

package/src/workflows/preview/pr-update.yml

@@ -44,119 +44,130 @@ jobs:
     if: needs.filter.outputs.theme == 'true'
     runs-on: ubuntu-latest
     outputs:
-      store_alias: ${{ steps.resolve.outputs.alias }}
-      store_alias_secret: ${{ steps.resolve.outputs.alias_secret }}
+      store_alias: ${{ steps.resolve.outputs.store_alias }}
+      store_alias_secret: ${{ steps.resolve.outputs.store_alias_secret }}
+      preview_targets_json: ${{ steps.resolve.outputs.preview_targets_json }}
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Resolve store alias from base branch
+      - name: Resolve preview store targets from base branch
         id: resolve
         env:
           BASE_REF: ${{ github.event.pull_request.base.ref }}
         run: |
-          # On staging-<alias> or live-<alias> PRs, use that store; otherwise default store
-          if [[ -n "$BASE_REF" && ("$BASE_REF" == staging-* || "$BASE_REF" == live-*) ]]; then
-            ALIAS="${BASE_REF#staging-}"
-            ALIAS="${ALIAS#live-}"
-          else
-            ALIAS=$(node -e "
-              const fs = require('fs');
-              const cfg = JSON.parse(fs.readFileSync('./climaybe.config.json', 'utf8'));
-              const stores = cfg?.stores || {};
-              const defaultStoreRaw = cfg?.default_store;
-              const normalize = (v) => String(v || '')
-                .toLowerCase()
-                .replace(/^https?:\\/\\//, '')
-                .replace(/\\/.*$/, '');
-              const defaultStore = normalize(defaultStoreRaw);
-              let alias = '';
-              if (defaultStore) {
-                for (const [k, d] of Object.entries(stores)) {
-                  if (normalize(d) === defaultStore) {
-                    alias = k;
-                    break;
-                  }
+          node <<'NODE' >>"$GITHUB_OUTPUT"
+          const fs = require('fs');
+          const cfg = JSON.parse(fs.readFileSync('climaybe.config.json', 'utf8'));
+          const stores = cfg?.stores || {};
+          const keys = Object.keys(stores);
+          const baseRef = process.env.BASE_REF || '';
+          const isMulti = keys.length > 1;
+          const isStagingLive =
+            baseRef && (/^staging-/.test(baseRef) || /^live-/.test(baseRef));
+
+          const aliasToSecret = (a) => String(a).toUpperCase().replace(/-/g, '_');
+          const normalizeDomain = (v) =>
+            String(v || '')
+              .toLowerCase()
+              .replace(/^https?:\/\//, '')
+              .replace(/\/.*$/, '');
+
+          let targets = [];
+          if (isMulti && !isStagingLive) {
+            targets = keys.map((alias) => ({ alias, alias_secret: aliasToSecret(alias) }));
+          } else if (isStagingLive) {
+            let a = baseRef.replace(/^staging-/, '').replace(/^live-/, '');
+            targets = [{ alias: a, alias_secret: aliasToSecret(a) }];
+          } else {
+            const defaultStoreNorm = normalizeDomain(cfg?.default_store);
+            let alias = '';
+            if (defaultStoreNorm) {
+              for (const [k, d] of Object.entries(stores)) {
+                if (normalizeDomain(d) === defaultStoreNorm) {
+                  alias = k;
+                  break;
                 }
               }
-              if (!alias) {
-                alias = Object.keys(stores)[0] || '';
-              }
-              if (!alias && defaultStore) {
-                const subdomain = defaultStore.split('.')[0] || 'default';
-                alias = subdomain.replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-') || 'default';
-              }
-              if (!alias) {
-                alias = 'default';
-              }
-              process.stdout.write(alias);
-            ")
-          fi
+            }
+            if (!alias) alias = keys[0] || '';
+            if (!alias && cfg?.default_store) {
+              const sub = normalizeDomain(cfg.default_store).split('.')[0] || 'default';
+              alias = sub.replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-') || 'default';
+            }
+            if (!alias) alias = 'default';
+            targets = [{ alias, alias_secret: aliasToSecret(alias) }];
+          }
 
-          if [ -z "$ALIAS" ]; then
-            echo "Could not resolve default store alias from climaybe.config.json config."
-            exit 1
-          fi
+          if (targets.length === 0 || targets.some((t) => !t.alias)) {
+            console.error('Could not resolve store targets from climaybe.config.json');
+            process.exit(1);
+          }
 
-          ALIAS_SECRET=$(echo "$ALIAS" | tr '[:lower:]-' '[:upper:]_')
-          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
-          echo "alias_secret=$ALIAS_SECRET" >> $GITHUB_OUTPUT
+          console.log('preview_targets_json<<PT_JSON');
+          console.log(JSON.stringify(targets));
+          console.log('PT_JSON');
+          console.log(`store_alias=${targets[0].alias}`);
+          console.log(`store_alias_secret=${targets[0].alias_secret}`);
+          NODE
 
-      - name: Validate Shopify credentials
+  validate-secrets-per-store:
+    needs: [validate-environment]
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(needs.validate-environment.outputs.preview_targets_json) }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Require Shopify URL + theme token for this store
         env:
-          SHOPIFY_STORE_URL_SCOPED: ${{ secrets[format('SHOPIFY_STORE_URL_{0}', steps.resolve.outputs.alias_secret)] }}
-          SHOPIFY_THEME_ACCESS_TOKEN_SCOPED: ${{ secrets[format('SHOPIFY_THEME_ACCESS_TOKEN_{0}', steps.resolve.outputs.alias_secret)] }}
+          SHOPIFY_STORE_URL_SCOPED: ${{ secrets[format('SHOPIFY_STORE_URL_{0}', matrix.alias_secret)] }}
+          SHOPIFY_THEME_ACCESS_TOKEN_SCOPED: ${{ secrets[format('SHOPIFY_THEME_ACCESS_TOKEN_{0}', matrix.alias_secret)] }}
           SHOPIFY_STORE_URL_DEFAULT: ${{ secrets.SHOPIFY_STORE_URL }}
           SHOPIFY_THEME_ACCESS_TOKEN_DEFAULT: ${{ secrets.SHOPIFY_THEME_ACCESS_TOKEN }}
         run: |
           SHOPIFY_STORE_URL="${SHOPIFY_STORE_URL_SCOPED:-$SHOPIFY_STORE_URL_DEFAULT}"
           SHOPIFY_THEME_ACCESS_TOKEN="${SHOPIFY_THEME_ACCESS_TOKEN_SCOPED:-$SHOPIFY_THEME_ACCESS_TOKEN_DEFAULT}"
-
-          if [ -z "$SHOPIFY_STORE_URL" ]; then
-            echo "No store URL secret found. Expected SHOPIFY_STORE_URL_${{ steps.resolve.outputs.alias_secret }} or SHOPIFY_STORE_URL."
+          if [ -z "$SHOPIFY_STORE_URL" ] || [ -z "$SHOPIFY_THEME_ACCESS_TOKEN" ]; then
+            echo "Missing SHOPIFY_* for ${{ matrix.alias }} (secret suffix ${{ matrix.alias_secret }})."
             exit 1
           fi
-          if [ -z "$SHOPIFY_THEME_ACCESS_TOKEN" ]; then
-            echo "No theme token secret found. Expected SHOPIFY_THEME_ACCESS_TOKEN_${{ steps.resolve.outputs.alias_secret }} or SHOPIFY_THEME_ACCESS_TOKEN."
-            exit 1
-          fi
-          echo "Shopify credentials are configured for alias: ${{ steps.resolve.outputs.alias }}"
+          echo "Shopify credentials OK for ${{ matrix.alias }}"
 
   cleanup-themes:
-    needs: [extract-pr-number, validate-environment]
+    needs: [extract-pr-number, validate-secrets-per-store]
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(needs.validate-environment.outputs.preview_targets_json) }}
     uses: ./.github/workflows/reusable-cleanup-themes.yml
     with:
+      cleanup_mode: by_pr
       pr_number: ${{ needs.extract-pr-number.outputs.pr_number }}
-      store_alias_secret: ${{ needs.validate-environment.outputs.store_alias_secret }}
+      store_alias_secret: ${{ matrix.alias_secret }}
     secrets: inherit
 
-  share-theme:
+  publish-preview-store:
     needs: [validate-environment, extract-pr-number, cleanup-themes]
-    uses: ./.github/workflows/reusable-share-theme.yml
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(needs.validate-environment.outputs.preview_targets_json) }}
+    uses: ./.github/workflows/reusable-publish-pr-preview-store.yml
     with:
       pr_number: ${{ needs.extract-pr-number.outputs.pr_number }}
-      store_alias: ${{ needs.validate-environment.outputs.store_alias }}
-      store_alias_secret: ${{ needs.validate-environment.outputs.store_alias_secret }}
-    secrets: inherit
-
-  rename-theme:
-    needs: [share-theme, extract-pr-number, validate-environment]
-    uses: ./.github/workflows/reusable-rename-theme.yml
-    with:
-      theme_id: ${{ needs.share-theme.outputs.theme_id }}
-      theme_name: ${{ needs.share-theme.outputs.theme_name }}
-      pr_number: ${{ needs.extract-pr-number.outputs.pr_number }}
-      store_alias: ${{ needs.validate-environment.outputs.store_alias }}
-      store_alias_secret: ${{ needs.validate-environment.outputs.store_alias_secret }}
+      store_alias: ${{ matrix.alias }}
+      store_alias_secret: ${{ matrix.alias_secret }}
     secrets: inherit
 
   comment-on-pr:
-    needs: [share-theme, rename-theme, extract-pr-number, validate-environment]
+    needs: [publish-preview-store, extract-pr-number, validate-environment]
     uses: ./.github/workflows/reusable-comment-on-pr.yml
     with:
-      theme_id: ${{ needs.share-theme.outputs.theme_id }}
-      share_output: ${{ needs.share-theme.outputs.share_output }}
+      theme_id: ${{ needs.publish-preview-store.outputs.theme_id }}
+      share_output: ${{ needs.publish-preview-store.outputs.share_output }}
       pr_number: ${{ needs.extract-pr-number.outputs.pr_number_unpadded }}
       store_alias: ${{ needs.validate-environment.outputs.store_alias }}
       store_alias_secret: ${{ needs.validate-environment.outputs.store_alias_secret }}
+      use_preview_fragments: 'true'
     secrets: inherit

package/src/workflows/preview/reusable-cleanup-themes.yml

@@ -3,14 +3,25 @@ name: Cleanup Themes
 on:
   workflow_call:
     inputs:
+      cleanup_mode:
+        required: false
+        type: string
+        default: 'by_pr'
+        description: "by_pr: delete themes whose name ends with -PR{pr_number} (padded). orphan_pr: delete themes ending with -PR<n> when PR n is not open in this repo."
       pr_number:
-        required: true
+        required: false
         type: string
-        description: "PR number to clean up themes for"
+        default: ''
+        description: "Padded PR number (e.g. 09) when cleanup_mode is by_pr; ignored for orphan_pr."
       store_alias_secret:
         required: false
         type: string
         description: "Upper snake-case alias for scoped secret (e.g. VOLDT_STAGING). If set, uses SHOPIFY_*_<this>; else uses SHOPIFY_STORE_URL / SHOPIFY_THEME_ACCESS_TOKEN."
+      result_artifact_prefix:
+        required: false
+        type: string
+        default: ''
+        description: "When non-empty, uploads a tiny artifact named {prefix}-{store_alias_secret} with deleted_count for matrix fan-in."
     outputs:
       deleted_count:
         description: "Number of deleted themes"
@@ -18,13 +29,33 @@ on:
       deleted_themes:
         description: "Deleted theme names, one per line"
         value: ${{ jobs.cleanup.outputs.deleted_themes }}
+      matched_count:
+        description: "Number of themes matching this PR (before delete)"
+        value: ${{ jobs.cleanup.outputs.matched_count }}
+      matched_themes:
+        description: "Matched theme names, one per line (before delete)"
+        value: ${{ jobs.cleanup.outputs.matched_themes }}
+      skipped_reason:
+        description: "Why cleanup was skipped (empty if not skipped)"
+        value: ${{ jobs.cleanup.outputs.skipped_reason }}
+      store_hint:
+        description: "Redacted store host (best-effort; may be masked)"
+        value: ${{ jobs.cleanup.outputs.store_hint }}
 
 jobs:
   cleanup:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      actions: write
     outputs:
       deleted_count: ${{ steps.cleanup.outputs.deleted_count }}
       deleted_themes: ${{ steps.cleanup.outputs.deleted_themes }}
+      matched_count: ${{ steps.cleanup.outputs.matched_count }}
+      matched_themes: ${{ steps.cleanup.outputs.matched_themes }}
+      skipped_reason: ${{ steps.cleanup.outputs.skipped_reason }}
+      store_hint: ${{ steps.cleanup.outputs.store_hint }}
     steps:
       - name: Install Shopify CLI
         run: npm install -g @shopify/cli @shopify/theme
@@ -35,44 +66,219 @@ jobs:
           SHOPIFY_STORE_URL: ${{ inputs.store_alias_secret && secrets[format('SHOPIFY_STORE_URL_{0}', inputs.store_alias_secret)] || secrets.SHOPIFY_STORE_URL }}
           SHOPIFY_THEME_ACCESS_TOKEN: ${{ inputs.store_alias_secret && secrets[format('SHOPIFY_THEME_ACCESS_TOKEN_{0}', inputs.store_alias_secret)] || secrets.SHOPIFY_THEME_ACCESS_TOKEN }}
           PR_NUMBER: ${{ inputs.pr_number }}
+          CLEANUP_MODE: ${{ inputs.cleanup_mode }}
+          STORE_ALIAS_SECRET: ${{ inputs.store_alias_secret }}
+          RESULT_ARTIFACT_PREFIX: ${{ inputs.result_artifact_prefix }}
+          GH_TOKEN: ${{ github.token }}
         run: |
-          if [ -z "$SHOPIFY_STORE_URL" ] || [ -z "$SHOPIFY_THEME_ACCESS_TOKEN" ]; then
+          set -euo pipefail
+
+          STORE_HOST="${SHOPIFY_STORE_URL#https://}"
+          STORE_HOST="${STORE_HOST#http://}"
+          STORE_HOST="${STORE_HOST%%/*}"
+
+          {
+            echo "### 🧹 Cleanup preview themes"
+            echo ""
+            echo "- **Mode**: \`${CLEANUP_MODE}\`"
+            echo "- **PR (by_pr mode)**: \`${PR_NUMBER:-<n/a>}\`"
+            echo "- **Store alias secret**: \`${STORE_ALIAS_SECRET:-<default>}\`"
+            echo "- **Store (host)**: \`${STORE_HOST:-<missing>}\`"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+          echo "CLEANUP_MODE=${CLEANUP_MODE}"
+          echo "PR=${PR_NUMBER}"
+          echo "Store alias secret=${STORE_ALIAS_SECRET:-<default>}"
+          echo "Store host=${STORE_HOST:-<missing>}"
+
+          if [ -z "${SHOPIFY_STORE_URL:-}" ] || [ -z "${SHOPIFY_THEME_ACCESS_TOKEN:-}" ]; then
             echo "Missing Shopify secrets; skipping theme cleanup (no themes deleted)."
-            echo "deleted_count=0" >> $GITHUB_OUTPUT
-            echo "deleted_themes<<DELETED_EOF" >> $GITHUB_OUTPUT
-            echo "DELETED_EOF" >> $GITHUB_OUTPUT
+
+            {
+              echo ""
+              echo "#### Result"
+              echo "- **Skipped**: yes (missing Shopify secrets)"
+              echo "- **Matched themes**: 0"
+              echo "- **Deleted themes**: 0"
+            } >> "$GITHUB_STEP_SUMMARY"
+
+            echo "skipped_reason=missing_secrets" >> "$GITHUB_OUTPUT"
+            echo "store_hint=${STORE_HOST:-}" >> "$GITHUB_OUTPUT"
+            echo "matched_count=0" >> "$GITHUB_OUTPUT"
+            echo "matched_themes<<MATCHED_EOF" >> "$GITHUB_OUTPUT"
+            echo "MATCHED_EOF" >> "$GITHUB_OUTPUT"
+            echo "deleted_count=0" >> "$GITHUB_OUTPUT"
+            echo "deleted_themes<<DELETED_EOF" >> "$GITHUB_OUTPUT"
+            echo "DELETED_EOF" >> "$GITHUB_OUTPUT"
             exit 0
           fi
 
-          THEME_LIST=$(shopify theme list \
+          if [ "$CLEANUP_MODE" = "by_pr" ] && [ -z "${PR_NUMBER:-}" ]; then
+            echo "cleanup_mode is by_pr but pr_number is empty."
+            exit 1
+          fi
+
+          echo "store_hint=${STORE_HOST:-}" >> "$GITHUB_OUTPUT"
+          echo "skipped_reason=" >> "$GITHUB_OUTPUT"
+
+          THEME_LIST_ERR="$(mktemp)"
+          THEME_LIST_JSON="$(mktemp)"
+
+          if ! shopify theme list \
             --store "$SHOPIFY_STORE_URL" \
             --password "$SHOPIFY_THEME_ACCESS_TOKEN" \
-            --json 2>/dev/null || echo "[]")
+            --json > "$THEME_LIST_JSON" 2> "$THEME_LIST_ERR"; then
+            echo "shopify theme list failed."
+            echo "Error output (first 120 lines):"
+            sed -n '1,120p' "$THEME_LIST_ERR" || true
+            {
+              echo ""
+              echo "#### Result"
+              echo "- **Error**: \`shopify theme list\` failed"
+              echo ""
+              echo "<details><summary>CLI error output</summary>"
+              echo ""
+              echo "\`\`\`"
+              sed -n '1,240p' "$THEME_LIST_ERR" || true
+              echo "\`\`\`"
+              echo "</details>"
+            } >> "$GITHUB_STEP_SUMMARY"
+            exit 1
+          fi
+
+          if [ ! -s "$THEME_LIST_JSON" ]; then
+            echo "[]" > "$THEME_LIST_JSON"
+          fi
+
+          ALL_COUNT="$(jq -r 'length' "$THEME_LIST_JSON" 2>/dev/null || echo "0")"
+          echo "Found ${ALL_COUNT} total theme(s) on store."
 
+          MATCHED_COUNT=0
+          MATCHED_THEMES=""
           DELETED_COUNT=0
           DELETED_THEMES=""
 
+          OPEN_PRS_FILE="$(mktemp)"
+          if [ "$CLEANUP_MODE" = "orphan_pr" ]; then
+            echo "Fetching open PR numbers (limit 1000)…"
+            if ! gh pr list --repo "${GITHUB_REPOSITORY}" --state open --limit 1000 --json number -q '.[].number' > "$OPEN_PRS_FILE" 2>/dev/null; then
+              echo "gh pr list failed; cannot determine open PRs safely. Skipping orphan cleanup."
+              {
+                echo ""
+                echo "#### Result"
+                echo "- **Skipped**: \`gh pr list\` failed (check \`pull-requests: read\` permission)"
+              } >> "$GITHUB_STEP_SUMMARY"
+              echo "skipped_reason=gh_pr_list_failed" >> "$GITHUB_OUTPUT"
+              echo "matched_count=0" >> "$GITHUB_OUTPUT"
+              echo "matched_themes<<MATCHED_EOF" >> "$GITHUB_OUTPUT"
+              echo "MATCHED_EOF" >> "$GITHUB_OUTPUT"
+              echo "deleted_count=0" >> "$GITHUB_OUTPUT"
+              echo "deleted_themes<<DELETED_EOF" >> "$GITHUB_OUTPUT"
+              echo "DELETED_EOF" >> "$GITHUB_OUTPUT"
+              rm -f "$THEME_LIST_ERR" "$THEME_LIST_JSON" "$OPEN_PRS_FILE"
+              exit 0
+            fi
+            echo "Open PR count (lines): $(wc -l < "$OPEN_PRS_FILE" | tr -d ' ')"
+          fi
+
+          should_delete_theme() {
+            local id="$1"
+            local name="$2"
+            local suffix=""
+            suffix="$(printf '%s' "$name" | sed -n 's/.*-PR\([0-9][0-9]*\)$/\1/p')"
+            if [ -z "$suffix" ]; then
+              return 1
+            fi
+            if [ "$CLEANUP_MODE" = "by_pr" ]; then
+              case "$name" in
+                *"-PR${PR_NUMBER}") return 0 ;;
+                *) return 1 ;;
+              esac
+            fi
+            if [ "$CLEANUP_MODE" = "orphan_pr" ]; then
+              local num=""
+              num=$((10#$suffix))
+              if grep -qx "$num" "$OPEN_PRS_FILE" 2>/dev/null; then
+                return 1
+              fi
+              return 0
+            fi
+            return 1
+          }
+
           while IFS=$'\t' read -r THEME_ID THEME_NAME; do
             [ -z "$THEME_ID" ] && continue
             [ -z "$THEME_NAME" ] && continue
 
-            if printf "%s" "$THEME_NAME" | grep -q "PR${PR_NUMBER}"; then
+            if should_delete_theme "$THEME_ID" "$THEME_NAME"; then
+              MATCHED_COUNT=$((MATCHED_COUNT + 1))
+              MATCHED_THEMES="${MATCHED_THEMES}${THEME_NAME}\n"
+              echo "Matched: $THEME_NAME ($THEME_ID)"
+
+              DELETE_ERR="$(mktemp)"
               if shopify theme delete \
                 --store "$SHOPIFY_STORE_URL" \
                 --password "$SHOPIFY_THEME_ACCESS_TOKEN" \
                 --force \
-                --theme "$THEME_ID" 2>/dev/null; then
+                --theme "$THEME_ID" 1>/dev/null 2>"$DELETE_ERR"; then
                 DELETED_COUNT=$((DELETED_COUNT + 1))
                 DELETED_THEMES="${DELETED_THEMES}${THEME_NAME}\n"
+                echo "Deleted: $THEME_NAME ($THEME_ID)"
               else
-                echo "Failed to delete theme: $THEME_NAME ($THEME_ID)"
+                echo "Failed to delete: $THEME_NAME ($THEME_ID)"
+                echo "Delete error output (first 80 lines):"
+                sed -n '1,80p' "$DELETE_ERR" || true
               fi
             fi
-          done < <(echo "$THEME_LIST" | jq -r '.[] | [.id, .name] | @tsv')
+          done < <(jq -r '.[] | [.id, .name] | @tsv' "$THEME_LIST_JSON")
 
-          echo "deleted_count=$DELETED_COUNT" >> $GITHUB_OUTPUT
+          {
+            echo ""
+            echo "#### Result"
+            echo "- **Total themes on store**: ${ALL_COUNT}"
+            echo "- **Matched**: ${MATCHED_COUNT}"
+            echo "- **Deleted**: ${DELETED_COUNT}"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+          if [ "$MATCHED_COUNT" -gt 0 ]; then
+            {
+              echo ""
+              echo "#### Matched theme names"
+              printf "%b" "$MATCHED_THEMES" | sed -e 's/^/- /'
+            } >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+          if [ "$DELETED_COUNT" -gt 0 ]; then
+            {
+              echo ""
+              echo "#### Deleted theme names"
+              printf "%b" "$DELETED_THEMES" | sed -e 's/^/- /'
+            } >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+          echo "matched_count=$MATCHED_COUNT" >> "$GITHUB_OUTPUT"
+          {
+            echo "matched_themes<<MATCHED_EOF"
+            printf "%b" "$MATCHED_THEMES"
+            echo "MATCHED_EOF"
+          } >> "$GITHUB_OUTPUT"
+
+          echo "deleted_count=$DELETED_COUNT" >> "$GITHUB_OUTPUT"
           {
             echo "deleted_themes<<DELETED_EOF"
             printf "%b" "$DELETED_THEMES"
             echo "DELETED_EOF"
-          } >> $GITHUB_OUTPUT
+          } >> "$GITHUB_OUTPUT"
+
+          rm -f "$THEME_LIST_ERR" "$THEME_LIST_JSON" "$OPEN_PRS_FILE"
+
+      - name: Upload deleted count for matrix fan-in
+        if: inputs.result_artifact_prefix != ''
+        run: printf '%s' '${{ steps.cleanup.outputs.deleted_count }}' > deleted-count.txt
+      - name: Save cleanup result artifact
+        if: inputs.result_artifact_prefix != ''
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ inputs.result_artifact_prefix }}-${{ inputs.store_alias_secret }}
+          path: deleted-count.txt
+          retention-days: 2

package/src/workflows/preview/reusable-comment-on-pr.yml

@@ -19,11 +19,29 @@ on:
         required: false
         type: string
         description: "Upper snake-case alias for scoped secret (e.g. VOLDT_STAGING). If set, uses SHOPIFY_STORE_URL_<this>; else uses SHOPIFY_STORE_URL."
+      use_preview_fragments:
+        required: false
+        type: string
+        default: 'false'
+        description: "When 'true', download preview-fragment-* artifacts (from publish matrix) and post one comment with all preview URLs."
 
 jobs:
   comment:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      actions: read
+      pull-requests: write
     steps:
+      - name: Download preview fragments (multi-store / matrix publish)
+        if: inputs.use_preview_fragments == 'true'
+        continue-on-error: true
+        uses: actions/download-artifact@v4
+        with:
+          pattern: preview-fragment-*
+          merge-multiple: true
+          path: preview-fragments
+
       - name: Post preview comment
         uses: actions/github-script@v7
         env:
@@ -31,39 +49,85 @@ jobs:
           THEME_ID: ${{ inputs.theme_id }}
           SHARE_OUTPUT: ${{ inputs.share_output }}
           PR_NUMBER: ${{ inputs.pr_number }}
+          USE_PREVIEW_FRAGMENTS: ${{ inputs.use_preview_fragments }}
         with:
           script: |
+            const fs = require('fs');
+            const path = require('path');
             const issueNumber = parseInt(process.env.PR_NUMBER);
-            const storeDomain = (process.env.SHOPIFY_STORE_URL || '')
-              .replace(/^https?:\/\//, '')
-              .replace(/\/$/, '');
-            const themeId = process.env.THEME_ID || '';
-            const shareOutput = process.env.SHARE_OUTPUT || '';
+            const useFragments = process.env.USE_PREVIEW_FRAGMENTS === 'true';
 
-            let previewUrl = '';
-            let customizeUrl = '';
-            if (storeDomain && themeId) {
-              previewUrl = `https://${storeDomain}?preview_theme_id=${themeId}`;
-              customizeUrl = `https://${storeDomain}/admin/themes/${themeId}/editor`;
+            const walkJsonFiles = (dir) => {
+              const out = [];
+              if (!fs.existsSync(dir)) return out;
+              const stack = [dir];
+              while (stack.length) {
+                const d = stack.pop();
+                for (const ent of fs.readdirSync(d, { withFileTypes: true })) {
+                  const p = path.join(d, ent.name);
+                  if (ent.isDirectory()) stack.push(p);
+                  else if (ent.name === 'fragment.json' || ent.name.endsWith('.json')) {
+                    try {
+                      out.push(JSON.parse(fs.readFileSync(p, 'utf8')));
+                    } catch {
+                      // ignore
+                    }
+                  }
+                }
+              }
+              return out;
+            };
+
+            let fragments = [];
+            if (useFragments) {
+              fragments = walkJsonFiles('preview-fragments');
             }
 
             const parts = [
               '## 🎨 Theme Preview Generated',
               '',
-              `**Store:** ${process.env.SHOPIFY_STORE_URL || 'N/A'}`,
               `**Branch:** ${context.payload.pull_request?.head?.ref || context.ref.replace('refs/heads/', '')}`,
               `**Commit:** ${(context.payload.pull_request?.head?.sha || context.sha || '').substring(0, 7)}`
             ];
 
-            if (customizeUrl) {
-              parts.push('', `**Customize URL:** ${customizeUrl}`);
-            }
-            if (previewUrl) {
-              parts.push('', `**Preview URL:** ${previewUrl}`);
-            }
-            if (shareOutput.trim()) {
-              parts.push('', '### Share Output', '```', shareOutput, '```');
+            if (fragments.length > 0) {
+              parts.push('', '### Preview links (per store)');
+              const byAlias = [...fragments].sort((a, b) => String(a.alias).localeCompare(String(b.alias)));
+              for (const f of byAlias) {
+                const host = (f.store_host || '').replace(/\/$/, '');
+                const tid = f.theme_id || '';
+                const alias = f.alias || 'store';
+                if (host && tid) {
+                  const previewUrl = `https://${host}?preview_theme_id=${tid}`;
+                  const customizeUrl = `https://${host}/admin/themes/${tid}/editor`;
+                  parts.push('', `**${alias}**`, `- Customize: ${customizeUrl}`, `- Preview: ${previewUrl}`);
+                }
+              }
+            } else if (useFragments) {
+              parts.push(
+                '',
+                '*(Could not load per-store preview fragments from workflow artifacts; see the publish job logs.)*'
+              );
+            } else {
+              const storeDomain = (process.env.SHOPIFY_STORE_URL || '')
+                .replace(/^https?:\/\//, '')
+                .replace(/\/$/, '');
+              const themeId = process.env.THEME_ID || '';
+              const shareOutput = process.env.SHARE_OUTPUT || '';
+              parts.push('', `**Store:** ${process.env.SHOPIFY_STORE_URL || 'N/A'}`);
+              let previewUrl = '';
+              let customizeUrl = '';
+              if (storeDomain && themeId) {
+                previewUrl = `https://${storeDomain}?preview_theme_id=${themeId}`;
+                customizeUrl = `https://${storeDomain}/admin/themes/${themeId}/editor`;
+              }
+              if (customizeUrl) parts.push('', `**Customize URL:** ${customizeUrl}`);
+              if (previewUrl) parts.push('', `**Preview URL:** ${previewUrl}`);
+              if (shareOutput.trim()) {
+                parts.push('', '### Share Output', '```', shareOutput, '```');
+              }
             }
+
             parts.push('', '---', '*This preview will be available for 7 days.*');
 
             await github.rest.issues.createComment({