Merge pull request '分組保留 KEEP_COUNT 與移除 RUNNER_TOKEN' (#5) from develop into master

Reviewed-on: #5

.gitea/ai-review/exclusions.json

@@ -134,5 +134,37 @@
     "role": "Bard",
     "original_finding": "統一成同一套語彙，例如把 `section()` 改成 `setLogSection()`，並讓相關變數名稱也跟著一致。",
     "reason": "AI 對話收斂判定為誤報（問題在最新程式碼中不成立或不適用）"
+  },
+  {
+    "location": "src/index.js:363",
+    "role": "Rogue",
+    "original_finding": "改用固定大小的 top-K 選擇策略，例如維持一個大小為 `KEEP_COUNT` 的最小堆，或在 API 已經有新到舊順序時直接取前 `KEEP_COUNT` 筆，避免整體排序。",
+    "reason": "release 數量預期不大，全量排序成本可忽略；後續同時需要「保留的前 K 筆」與「其餘待刪清單」，一次排序是最直接清楚的實作，引入 top-K 堆反而增加複雜度（與既有「分頁結果先完整收集到陣列」的排除理由一致）。",
+    "source": "develop...ai-review-resolve/develop-20260711-131608",
+    "date": "2026-07-15"
+  },
+  {
+    "location": "src/index.js:317",
+    "role": "Assassin",
+    "original_finding": "例外訊息只保留 HTTP 狀態碼與請求目標，不要預設帶回應 body；若真的需要除錯資訊，改成在受控的 debug 模式下才輸出，而且要先過濾敏感欄位並更短截斷。",
+    "reason": "已有等價防護：回應摘要先經 sanitizeLogText 去除控制字元（無法注入換行／ANSI 偽造 log），再截斷至 200 字；請求對象是參數檢查階段驗證過的 HTTPS Gitea 端點，非任意外部來源。保留截斷後的錯誤摘要對排查 API 失敗（如 403 權限訊息）必要，移除反而增加維運成本。",
+    "source": "develop...master",
+    "date": "2026-07-15"
+  },
+  {
+    "location": "action.yml:40",
+    "role": "Maya",
+    "original_finding": "補一個整合測試或 action 介面測試，驗證執行時確實會把 `gitea.token` 帶進 `process.env.GITEA_TOKEN`，且不再依賴舊的 `RUNNER_TOKEN` 輸入。",
+    "reason": "專案目前沒有任何測試框架或 package.json，為 action 介面契約補整合測試需要先建立測試基礎設施，超出本次修正範圍（與既有多筆測試覆蓋類排除一致）；此契約已由 CI 實際執行驗證（自動 token 成功清理 release/tag）。",
+    "source": "develop...ai-review-resolve/develop-20260715-133726",
+    "date": "2026-07-15"
+  },
+  {
+    "location": "src/index.js:426",
+    "role": "Maya",
+    "original_finding": "補一個有 token 的案例，驗證 log 只會出現 `[redacted]`，而實際送出的 header 會是 `token ${GITEA_TOKEN}`，同時不要把明文 token 暴露到輸出中。",
+    "reason": "專案目前沒有測試基礎設施，補授權分支的測試屬後續技術債（與既有多筆測試覆蓋類排除一致）；遮蔽輸出為固定字面值 [redacted]，不經任何插值，明文外洩風險已由程式結構排除。",
+    "source": "develop...ai-review-resolve/develop-20260715-133726",
+    "date": "2026-07-15"
   }
 ]

.gitea/ai-review/findings.json

@@ -1,98 +1 @@
-[
+[]
-  {
-    "level": "critical",
-    "role": "Mage",
-    "problem": "這裡在刪除 tag 的流程中只把失敗記進 `hadFailure`，但流程結束後沒有再檢查或拋錯。最小重現：只要任一個 tag 刪除回傳 404/500，程式仍會以 0 結束，外層 CI 會誤判為清理成功，但實際上遺留的 tag 還在。",
-    "suggestion": "在 `processInBatches(tagJson, ...)` 結束後補上 `if (hadFailure) throw new Error(...)`，讓任何 tag 刪除失敗都會正確回傳非 0 狀態。",
-    "location": "src/index.js:400",
-    "is_new": false
-  },
-  {
-    "level": "warning",
-    "role": "Mage",
-    "problem": "`Promise.all` 只要其中一個刪除任務拋出 reject，整個 batch 會立刻失敗，外層 `main().catch(...)` 也會直接結束。這代表只要某一筆 release 或 tag 遇到網路中斷、DNS 失敗、連線逾時，後續同 batch 的項目就不會再處理，清理流程會在半途中停住。",
-    "suggestion": "把每個 item 的刪除包在個別 `try/catch`，或改用 `Promise.allSettled` 後統一彙總失敗；至少要確保單筆失敗不會中止同批其他清理工作。",
-    "location": "src/index.js:282",
-    "is_new": false
-  },
-  {
-    "level": "warning",
-    "role": "Assassin",
-    "problem": "這個驗證只擋掉非數字，`0` 仍然會通過；若攻擊者能控制 `KEEP_COUNT`，就能把保留數設成 0，後續流程會把所有 release 刪光，還會把所有未被保留的 tag 一併清掉。",
-    "suggestion": "把下限改成至少 `1`，並在進入刪除流程前再做一次保護檢查；如果真的需要全清，應該改成獨立的高風險開關，而不是混在一般輸入參數裡。",
-    "location": "src/index.js:169",
-    "is_new": false
-  },
-  {
-    "level": "warning",
-    "role": "Assassin",
-    "location": "src/index.js:252",
-    "problem": "`GITEA_REPOSITORY` 直接字串串進 release API 路徑，沒有做格式驗證或路徑編碼。只要這個值被污染，攻擊者就能把 `../`、額外斜線或其他路徑片段塞進去，讓帶著授權 token 的請求打到非預期的 API 路徑，擴大刪除面。",
-    "suggestion": "先把 repository 嚴格限制為 `owner/repo` 這種固定格式，再對 owner 與 repo 各自做 `encodeURIComponent` 後組 URL，不要直接把原字串拼進路徑。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Assassin",
-    "location": "src/index.js:319",
-    "problem": "這裡同樣把未驗證的 `GITEA_REPOSITORY` 直接拼到 tag API 路徑。若輸入被操弄，攻擊者可以藉由路徑注入把刪除請求導向非預期資源，配合授權 token 造成超出原本 repo 範圍的破壞。",
-    "suggestion": "和 release API 一樣，對 repository 做嚴格格式檢查並逐段編碼後再組合路徑，必要時拒絕任何包含額外 `/`、`.` 或保留字元的值。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Leo",
-    "location": "src/index.js:227",
-    "problem": "`processInBatches()` 用 `Promise.all` 搭配外層共享的 `hadFailure`，失敗語意會變得很難推理：一筆例外會直接中斷整批，但其他並行工作仍可能繼續跑，最後到底刪了哪些、漏了哪些，不看執行細節很難判斷。這種控制流對日後補測試或改錯誤處理都不友善。",
-    "suggestion": "把每筆處理的結果收斂成明確的成功/失敗回傳值，或在批次內逐筆捕捉錯誤後再彙總；若要保留並行，至少讓批次函式回傳可測試的結果集合，而不是依賴外部可變狀態。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Mage",
-    "location": "src/index.js:345",
-    "problem": "`GITEA_SERVER_URL` 只做非空檢查，沒有先確認它是合法的絕對 URL。只要傳入像 `gitea.local`、`https://` 這類看起來有值但格式不合法的字串，`new URL()` 就會直接丟出未處理例外，錯誤也不會明確指出是參數格式問題。",
-    "suggestion": "在進入主流程前先對 `GITEA_SERVER_URL` 做 `try/catch` 驗證，失敗時回傳明確的參數錯誤並結束；不要把 URL 解析失敗留到中途才爆。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Mage",
-    "location": "src/index.js:336",
-    "problem": "`KEEP_COUNT` 只驗證是數字字串，沒有保證落在安全整數範圍內。像 `9007199254740993` 這種值會在 `Number()` 轉換時失真，導致 `releaseCount <= keepCount` 與 `slice(keepCount)` 的保留/刪除判斷偏掉，最終清理結果可能和設定不一致。",
-    "suggestion": "除了字串格式外，還要驗證 `Number.isSafeInteger(Number(KEEP_COUNT))`，並加上合理上限；超出範圍時直接報錯，避免用不精確的數值做刪除決策。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Rogue",
-    "location": "src/index.js:363",
-    "problem": "`releaseJson.sort(...)` 先把所有 release 做完整排序，成本是 O(n log n)，但後面其實只用前 `KEEP_COUNT` 筆。當 release 很多時，這段排序就是多花 CPU 在不必要的全量比較上。",
-    "suggestion": "改用固定大小的 top-K 選擇策略，例如維持一個大小為 `KEEP_COUNT` 的最小堆，或在 API 已經有新到舊順序時直接取前 `KEEP_COUNT` 筆，避免整體排序。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Rogue",
-    "location": "src/index.js:230",
-    "problem": "這裡對每個 request 都先建立 `chunks` 陣列、收完整個 response body，再 `join` 成字串。刪除 release/tag 時大多只需要狀態碼，還硬把回應內容完整緩衝進記憶體，會在大量刪除時增加不必要的配置與拷貝。",
-    "suggestion": "把 request 包成可選擇是否收集 body；對 DELETE 這類不需要回應內容的呼叫直接丟棄資料串流，只保留 status code。",
-    "is_new": true
-  },
-  {
-    "level": "info",
-    "role": "Assassin",
-    "problem": "分頁迴圈沒有上限，只要對方持續回傳非空頁面，這個 action 就會無限抓取；惡意或故障中的 API 可以把 runner 卡死，消耗時間與配額。",
-    "suggestion": "加入最大頁數、重複頁檢測或總筆數上限，超過就中止並回報異常，避免被外部回應拖成無限迴圈。",
-    "location": "src/index.js:228",
-    "is_new": false
-  },
-  {
-    "level": "info",
-    "role": "Leo",
-    "problem": "在 `catch` 裡先把 `currentStage` 清空再記錄錯誤，會讓最後那筆失敗 log 失去「到底是在哪個階段炸掉」的上下文。等到未來有人要追問題時，只能回頭翻前面的輸出，比對成本會很高。",
-    "suggestion": "保留最後的 `currentStage`，或在進入 `catch` 時把階段一起寫進錯誤訊息；如果擔心汙染後續輸出，可以在輸出完成後再重設，而不是先清空。",
-    "location": "src/index.js:409",
-    "is_new": false
-  }
-]

action.yml

@@ -1,5 +1,5 @@
 # 檔案用途：定義 CLEANUP OLD RELEASES 這個 Docker action 的輸入參數與執行環境
-# 更新日期：2026/07/11 21:02:25
+# 更新日期：2026/07/15 13:05:00
 
 # Action 名稱，會顯示在 action 市集與文件中
 name: 'CLEANUP OLD RELEASES'
@@ -12,14 +12,10 @@ author: 'Jeffery'
 
 # 定義可由使用者或呼叫端傳入的輸入參數
 inputs:
-  # RUNNER_TOKEN 用於授權呼叫 Gitea API；未提供時會改用 secrets
+  # KEEP_COUNT 用於控制保留的 release 數量；正式版與預發行版（prerelease）分組各自保留這個數量
-  RUNNER_TOKEN:
-    # 參數說明，讓呼叫端知道這是 Runner Token
-    description: 'Gitea Runner Token'
-  # KEEP_COUNT 用於控制保留的 release 數量
   KEEP_COUNT:
-    # 參數說明，這裡表示保留的版本數量
+    # 參數說明，這裡表示每組（正式版／預發行版）各自保留的版本數量
-    description: '保留的版本數量'
+    description: '保留的版本數量（正式版與預發行版各自保留）'
     # 預設保留 2 個版本，避免完全刪除歷史 release
     default: '2'
 
@@ -35,7 +31,7 @@ runs:
     GITEA_SERVER_URL: ${{ gitea.server_url }}
     # GITEA_REPOSITORY 由 Gitea runtime 注入，供程式指定目標 repo
     GITEA_REPOSITORY: ${{ gitea.repository }}
-    # 優先使用傳入的 RUNNER_TOKEN，否則退回 Gitea token secrets
+    # 使用 Gitea runtime 自動核發的 token，權限僅限當前 repo 且 job 結束即失效
-    RUNNER_TOKEN: ${{ inputs.RUNNER_TOKEN || secrets.GITEA_TOKEN || secrets.RUNNER_TOKEN }}
+    GITEA_TOKEN: ${{ gitea.token }}
     # KEEP_COUNT 直接沿用輸入值，交由程式驗證
     KEEP_COUNT: ${{ inputs.KEEP_COUNT }}

src/index.js

@@ -1,7 +1,7 @@
 const https = require('https');
 
 const DELETE_CONCURRENCY = 4;
-const MAX_PAGES = 1000;
+const DEFAULT_MAX_PAGES = 1000;
 
 const keepAliveAgent = new https.Agent({ keepAlive: true });
 
@@ -191,14 +191,52 @@ function requireValue(name, value, displayValue = value) {
 }
 
 /**
- * 驗證字串是否為非負整數。
+ * 驗證字串是否為正整數，且落在安全整數範圍內；下限 1 可避免把保留數設成 0 而清空所有 release。
  *
  * @param {string} name 參數名稱。
  * @param {string} value 參數值。
  */
-function requireInteger(name, value) {
+function requirePositiveInteger(name, value) {
-  if (!/^[0-9]+$/.test(value)) {
+  if (!/^[0-9]+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < 1) {
-    fail(`${name} must be a non-negative integer`);
+    fail(`${name} must be a positive integer within the safe integer range`);
+    process.exit(1);
+  }
+}
+
+/**
+ * 驗證值是否為合法的 HTTPS 絕對 URL，避免 URL 解析失敗留到主流程中途才拋出。
+ *
+ * @param {string} name 參數名稱。
+ * @param {*} value 參數值。
+ */
+function requireHttpsUrl(name, value) {
+  let parsed;
+  try {
+    parsed = new URL(String(value));
+  } catch (error) {
+    fail(`${name} must be a valid absolute URL`);
+    process.exit(1);
+  }
+
+  if (parsed.protocol !== 'https:') {
+    fail(`${name} must use HTTPS`);
+    process.exit(1);
+  }
+}
+
+/**
+ * 驗證 repository 是否為 `owner/repo` 格式且僅含安全字元，拒絕 `.`、`..` 等路徑片段。
+ *
+ * @param {string} name 參數名稱。
+ * @param {*} value 參數值。
+ */
+function requireRepository(name, value) {
+  const segments = String(value).split('/');
+  const isValidSegment = (segment) =>
+    /^[A-Za-z0-9_.-]+$/.test(segment) && segment !== '.' && segment !== '..';
+
+  if (segments.length !== 2 || !segments.every(isValidSegment)) {
+    fail(`${name} must be in owner/repo format`);
     process.exit(1);
   }
 }
@@ -207,10 +245,10 @@ function requireInteger(name, value) {
  * 對指定 URL 發送 request，回傳狀態碼與 body。
  *
  * @param {string} url 完整目標網址。
- * @param {{ method?: string, headers?: Record<string, string> }} [options] request 設定。
+ * @param {{ method?: string, headers?: Record<string, string>, collectBody?: boolean }} [options] request 設定；`collectBody` 為 `false` 時丟棄回應內容、只保留狀態碼。
  * @returns {Promise<{ statusCode: number, body: string }>} 回應狀態碼與內容。
  */
-function request(url, { method = 'GET', headers = {} } = {}) {
+function request(url, { method = 'GET', headers = {}, collectBody = true } = {}) {
   return new Promise((resolve, reject) => {
     const target = new URL(url);
     if (target.protocol !== 'https:') {
@@ -226,6 +264,16 @@ function request(url, { method = 'GET', headers = {} } = {}) {
         agent: keepAliveAgent,
       },
       (res) => {
+        const statusCode = res.statusCode || 0;
+
+        if (!collectBody) {
+          res.resume();
+          res.on('end', () => {
+            resolve({ statusCode, body: '' });
+          });
+          return;
+        }
+
         const chunks = [];
 
         res.setEncoding('utf8');
@@ -234,7 +282,7 @@ function request(url, { method = 'GET', headers = {} } = {}) {
         });
         res.on('end', () => {
           resolve({
-            statusCode: res.statusCode || 0,
+            statusCode,
             body: chunks.join(''),
           });
         });
@@ -247,18 +295,19 @@ function request(url, { method = 'GET', headers = {} } = {}) {
 }
 
 /**
- * 逐頁抓取 JSON 陣列資料，直到回傳空頁為止；超過 `MAX_PAGES` 即中止並回報異常。
+ * 逐頁抓取 JSON 陣列資料，直到回傳空頁為止；超過 `maxPages` 即中止並回報異常。
  *
  * @param {string} baseUrl 不含 page 參數的 API URL。
  * @param {Record<string, string>} headers request 標頭。
+ * @param {number} [maxPages=DEFAULT_MAX_PAGES] 分頁上限，可由環境變數 `MAX_PAGES` 覆寫。
  * @returns {Promise<any[]>} 合併後的陣列資料。
  */
-async function fetchAllPages(baseUrl, headers) {
+async function fetchAllPages(baseUrl, headers, maxPages = DEFAULT_MAX_PAGES) {
   const all = [];
 
   for (let page = 1; ; page += 1) {
-    if (page > MAX_PAGES) {
+    if (page > maxPages) {
-      throw new Error(`GET ${baseUrl} 分頁超過 ${MAX_PAGES} 頁上限，中止抓取以避免無限迴圈`);
+      throw new Error(`GET ${baseUrl} 分頁超過 ${maxPages} 頁上限，中止抓取以避免無限迴圈；資料量更大時可用 MAX_PAGES 環境變數調高上限`);
     }
 
     const pageUrl = `${baseUrl}?page=${page}`;
@@ -300,45 +349,83 @@ async function deleteResource(url, headers) {
   return request(url, {
     method: 'DELETE',
     headers,
+    collectBody: false,
   });
 }
 
 /**
- * 以固定批次大小處理項目，降低逐筆等待造成的延遲。
+ * 以固定批次大小處理項目，降低逐筆等待造成的延遲；單筆例外不會中止同批其他項目。
  *
  * @param {any[]} items 要處理的項目。
  * @param {number} batchSize 每批同時處理的數量。
- * @param {(item: any) => Promise<void>} handler 單筆處理函式。
+ * @param {(item: any) => Promise<boolean>} handler 單筆處理函式，回傳該筆是否成功。
+ * @returns {Promise<PromiseSettledResult<boolean>[]>} 依原始順序排列的處理結果。
  */
 async function processInBatches(items, batchSize, handler) {
+  const results = [];
+
   for (let index = 0; index < items.length; index += batchSize) {
     const batch = items.slice(index, index + batchSize);
-    await Promise.all(batch.map((item) => handler(item)));
+    results.push(...(await Promise.allSettled(batch.map((item) => handler(item)))));
   }
+
+  return results;
 }
 
 /**
- * 執行 release 與 tag 清理流程。
+ * 彙總批次結果；記錄被 reject 的例外，並回傳是否有任何一筆失敗。
+ *
+ * @param {PromiseSettledResult<boolean>[]} results 批次處理結果。
+ * @returns {boolean} 只要有任一筆失敗即回傳 `true`。
+ */
+function hasBatchFailure(results) {
+  let failed = false;
+
+  for (const result of results) {
+    if (result.status === 'rejected') {
+      failed = true;
+      const reason = result.reason;
+      fail(`批次處理發生例外: ${reason instanceof Error ? reason.message : String(reason)}`);
+    } else if (result.value === false) {
+      failed = true;
+    }
+  }
+
+  return failed;
+}
+
+/**
+ * 執行 release 與 tag 清理流程；正式版與預發行版（prerelease）分組計算，各自保留最新 `KEEP_COUNT` 筆。
  */
 async function main() {
   const GITEA_SERVER_URL = normalizeEnvValue(process.env.GITEA_SERVER_URL);
   const GITEA_REPOSITORY = normalizeEnvValue(process.env.GITEA_REPOSITORY);
-  const RUNNER_TOKEN = normalizeEnvValue(process.env.RUNNER_TOKEN) ?? '';
+  const GITEA_TOKEN = normalizeEnvValue(process.env.GITEA_TOKEN) ?? '';
   const KEEP_COUNT = normalizeEnvValue(process.env.KEEP_COUNT) ?? '';
+  const MAX_PAGES = normalizeEnvValue(process.env.MAX_PAGES) ?? '';
 
   section('參數檢查');
   requireValue('GITEA_SERVER_URL', GITEA_SERVER_URL, maskUrlForLog(GITEA_SERVER_URL));
+  requireHttpsUrl('GITEA_SERVER_URL', GITEA_SERVER_URL);
   requireValue('GITEA_REPOSITORY', GITEA_REPOSITORY);
+  requireRepository('GITEA_REPOSITORY', GITEA_REPOSITORY);
   requireValue('KEEP_COUNT', KEEP_COUNT);
-  requireInteger('KEEP_COUNT', KEEP_COUNT);
+  requirePositiveInteger('KEEP_COUNT', KEEP_COUNT);
+
+  let maxPages = DEFAULT_MAX_PAGES;
+  if (!isEmptyOrNull(MAX_PAGES)) {
+    info(`MAX_PAGES=${MAX_PAGES}`);
+    requirePositiveInteger('MAX_PAGES', MAX_PAGES);
+    maxPages = Number(MAX_PAGES);
+  }
 
   const keepCount = Number(KEEP_COUNT);
   const authHeaders = {};
-  if (isEmptyOrNull(RUNNER_TOKEN)) {
+  if (isEmptyOrNull(GITEA_TOKEN)) {
-    warn('RUNNER_TOKEN is empty; release API calls will be anonymous');
+    warn('GITEA_TOKEN is empty; release API calls will be anonymous');
   } else {
-    info('RUNNER_TOKEN=[redacted]');
+    info('GITEA_TOKEN=[redacted]');
-    authHeaders.Authorization = `token ${RUNNER_TOKEN}`;
+    authHeaders.Authorization = `token ${GITEA_TOKEN}`;
   }
 
   const serverBase = new URL(GITEA_SERVER_URL);
@@ -348,12 +435,13 @@ async function main() {
   serverBase.hash = '';
   const serverBaseUrl = serverBase.toString().replace(/\/+$/, '');
 
-  const releaseApiUrl = `${serverBaseUrl}/api/v1/repos/${GITEA_REPOSITORY}/releases`;
+  const repositoryPath = GITEA_REPOSITORY.split('/').map(encodeURIComponent).join('/');
+  const releaseApiUrl = `${serverBaseUrl}/api/v1/repos/${repositoryPath}/releases`;
 
   section('取得成品資訊');
   info(`GET ${releaseApiUrl}`);
 
-  const releaseJson = await fetchAllPages(releaseApiUrl, authHeaders);
+  const releaseJson = await fetchAllPages(releaseApiUrl, authHeaders, maxPages);
   releaseJson.sort((left, right) => {
     if (left.created_at < right.created_at) {
       return 1;
@@ -366,25 +454,28 @@ async function main() {
     return 0;
   });
 
-  const releaseCount = releaseJson.length;
+  const stableReleases = releaseJson.filter((item) => !item?.prerelease);
-  info(`RELEASE_COUNT=${releaseCount}`);
+  const preReleases = releaseJson.filter((item) => item?.prerelease);
+
+  info(`RELEASE_COUNT=${releaseJson.length}`);
+  info(`STABLE_COUNT=${stableReleases.length}`);
+  info(`PRERELEASE_COUNT=${preReleases.length}`);
   info(`KEEP_COUNT=${KEEP_COUNT}`);
 
-  let hadFailure = false;
+  const releaseToKeep = [...stableReleases.slice(0, keepCount), ...preReleases.slice(0, keepCount)];
+  const releaseToDelete = [...stableReleases.slice(keepCount), ...preReleases.slice(keepCount)];
 
-  if (releaseCount <= keepCount) {
+  if (releaseToDelete.length === 0) {
     info('沒有需要清理的舊版本成品');
   } else {
     section('刪除舊版本成品');
-
+    const releaseResults = await processInBatches(releaseToDelete, DELETE_CONCURRENCY, async (releaseItem) => {
-    const releaseToDelete = releaseJson.slice(keepCount);
-    await processInBatches(releaseToDelete, DELETE_CONCURRENCY, async (releaseItem) => {
       const releaseId = releaseItem?.id;
       if (!Number.isSafeInteger(releaseId) || releaseId <= 0) {
-        warn(
+        fail(
-          `略過 id 不是正整數的成品: ${sanitizeLogText(releaseItem?.tag_name || '')} (${sanitizeLogText(releaseItem?.name || '')})`,
+          `成品 id 不是正整數，視為資料異常: ${sanitizeLogText(releaseItem?.tag_name || '')} (${sanitizeLogText(releaseItem?.name || '')})`,
         );
-        return;
+        return false;
       }
 
       const releaseTag = sanitizeLogText(releaseItem.tag_name || '');
@@ -395,43 +486,43 @@ async function main() {
       const { statusCode } = await deleteResource(deleteUrl, authHeaders);
       if (statusCode === 204) {
         info(`成功刪除: ${releaseTag} (${releaseName})`);
-      } else {
+        return true;
-        hadFailure = true;
-        fail(`刪除失敗: ${releaseTag} (${releaseName}), HTTP ${statusCode}`);
-      }
-    });
       }
 
-  if (hadFailure) {
+      fail(`刪除失敗: ${releaseTag} (${releaseName}), HTTP ${statusCode}`);
+      return false;
+    });
+
+    if (hasBatchFailure(releaseResults)) {
       throw new Error('至少有一筆 release 刪除失敗');
     }
+  }
 
   section('刪除未指定 release 的 tag');
 
   const releaseTags = new Set(
-    releaseJson
+    releaseToKeep
-      .slice(0, keepCount)
       .map((item) => item?.tag_name)
       .filter((tag) => !isEmptyOrNull(tag)),
   );
 
-  const tagApiUrl = `${serverBaseUrl}/api/v1/repos/${GITEA_REPOSITORY}/tags`;
+  const tagApiUrl = `${serverBaseUrl}/api/v1/repos/${repositoryPath}/tags`;
   info(`GET ${tagApiUrl}`);
 
-  const tagJson = await fetchAllPages(tagApiUrl, authHeaders);
+  const tagJson = await fetchAllPages(tagApiUrl, authHeaders, maxPages);
   info(`TAG_COUNT=${tagJson.length}`);
 
-  await processInBatches(tagJson, DELETE_CONCURRENCY, async (tagItem) => {
+  const tagResults = await processInBatches(tagJson, DELETE_CONCURRENCY, async (tagItem) => {
     const tagName = tagItem?.name;
     if (isEmptyOrNull(tagName)) {
-      warn('略過沒有名稱的 tag');
+      fail('tag 缺少名稱，視為資料異常');
-      return;
+      return false;
     }
 
     const safeTagName = sanitizeLogText(tagName);
     if (releaseTags.has(tagName)) {
       info(`保留指定 release 的 tag: ${safeTagName}`);
-      return;
+      return true;
     }
 
     const deleteUrl = `${tagApiUrl}/${encodeURIComponent(tagName)}`;
@@ -440,20 +531,22 @@ async function main() {
     const { statusCode } = await deleteResource(deleteUrl, authHeaders);
     if (statusCode === 204) {
       info(`成功刪除未指定 release 的 tag: ${safeTagName}`);
-    } else {
+      return true;
-      hadFailure = true;
-      fail(`刪除 tag 失敗: ${safeTagName}, HTTP ${statusCode}`);
     }
+
+    fail(`刪除 tag 失敗: ${safeTagName}, HTTP ${statusCode}`);
+    return false;
   });
 
-  if (hadFailure) {
+  if (hasBatchFailure(tagResults)) {
     throw new Error('至少有一筆 tag 刪除失敗');
   }
 }
 
 main()
   .catch((error) => {
-    fail(error instanceof Error ? error.stack || error.message : String(error));
+    const showStack = process.env.RUNNER_DEBUG === '1';
+    fail(error instanceof Error ? (showStack && error.stack) || error.message : String(error));
     process.exitCode = 1;
   })
   .finally(() => {