chore: update ai-review findings [ai-review-bot][success]

- action.yml 移除 RUNNER_TOKEN input 與 secrets 回退鏈，env 簡化為 GITEA_TOKEN: ${{ gitea.token }}
- src/index.js 環境變數與 log 訊息同步改名為 GITEA_TOKEN，遮罩行為不變
- 自動 token 權限僅限當前 repo 且 job 結束即失效，已足夠本 action 的 release/tag 清理需求

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.gitea/ai-review/exclusions.json

@@ -63,5 +63,92 @@
     "reason": "專案目前沒有測試基礎設施，先將核心邏輯修正並保留此項為後續技術債。",
     "source": "develop...ai-review-resolve/develop-20260711-131608",
     "date": "2026-07-11"
+  },
+  {
+    "key": "src/index.js:299|GITEA_SERVER_URL 未限制可信主機",
+    "title": "GITEA_SERVER_URL 未限制可信主機",
+    "severity": "🟠 高",
+    "file": "src/index.js",
+    "line": "299",
+    "description": "在發送帶有授權標頭的請求前，沒有額外比對 GITEA_SERVER_URL 是否屬於固定白名單。",
+    "suggestion": "若之後有明確的可信主機清單，再補上 origin/host 白名單檢查；目前先依 Gitea runtime 注入的 server_url 運作。",
+    "verdict": "誤判",
+    "reason": "這個 action 只會在 Gitea runtime 提供的 `gitea.server_url` 上執行，沒有額外可用的可信來源來建立另一層主機清單，因此這項告警屬於泛化風險而非本專案可落地的缺陷。",
+    "source": "develop...ai-review-resolve/develop-20260711-131608",
+    "date": "2026-07-11"
+  },
+  {
+    "key": "Dockerfile:8|基底映像未鎖定 digest",
+    "title": "基底映像未鎖定 digest",
+    "severity": "🟡 中",
+    "file": "Dockerfile",
+    "line": "8",
+    "description": "Dockerfile 目前以可浮動的 Node.js 標籤作為基底映像。",
+    "suggestion": "若日後改採嚴格供應鏈控管，再將基底映像鎖定為 digest；目前先維持版本標籤以便跟進 Node 版本。",
+    "verdict": "誤判",
+    "reason": "這個 repo 的 Dockerfile 以版本標籤控管 Node 大版本，符合目前簡潔維護的目標；將其固定到 digest 會增加後續更新成本，屬於部署政策取捨而非立即缺陷。",
+    "source": "develop...ai-review-resolve/develop-20260711-131608",
+    "date": "2026-07-11"
+  },
+  {
+    "key": "src/index.js:1|檔案責任切分過於集中",
+    "title": "檔案責任切分過於集中",
+    "severity": "🟡 中",
+    "file": "src/index.js",
+    "line": "1",
+    "description": "單一檔案同時承擔 logger、驗證、HTTP client 與清理流程。",
+    "suggestion": "若之後擴充出更大的功能，再考慮拆分成獨立模組。",
+    "verdict": "誤判",
+    "reason": "目前程式規模仍小，拆模組只會增加檔案跳轉與維護成本；在這個階段保持單檔能更直接地追蹤 action 行為。",
+    "source": "develop...ai-review-resolve/develop-20260711-131608",
+    "date": "2026-07-11"
+  },
+  {
+    "key": "src/index.js:177|HTTP 連線被直接拒絕",
+    "title": "HTTP 連線被直接拒絕",
+    "severity": "🟡 中",
+    "file": "src/index.js",
+    "line": "177",
+    "description": "request helper 只允許 HTTPS，遇到 HTTP 端點會直接失敗。",
+    "suggestion": "若之後需要支援 HTTP 自架環境，再把協定限制做成可配置；目前先維持 HTTPS-only。",
+    "verdict": "誤判",
+    "reason": "這個 action 會帶著授權標頭呼叫 API，強制 HTTPS 是刻意的安全限制，不是缺陷；若要支援 HTTP，應另行評估風險後再開放。",
+    "source": "develop...ai-review-resolve/develop-20260711-131608",
+    "date": "2026-07-11"
+  },
+  {
+    "key": "src/index.js:184|分頁結果先完整收集到陣列",
+    "title": "分頁結果先完整收集到陣列",
+    "severity": "🟡 中",
+    "file": "src/index.js",
+    "line": "184",
+    "description": "fetchAllPages 會把所有頁面合併到單一陣列後再交給後續流程。",
+    "suggestion": "若未來資料量大幅成長，再考慮改成串流處理或分段消耗。",
+    "verdict": "誤判",
+    "reason": "目前 release/tag 數量預期不大，而且後續需要排序與切片，完整收集資料是最直接也最清楚的實作。",
+    "source": "develop...ai-review-resolve/develop-20260711-131608",
+    "date": "2026-07-11"
+  },
+  {
+    "location": "src/index.js:107",
+    "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"
   }
 ]

.gitea/ai-review/findings.json

@@ -1,90 +1,18 @@
 [
   {
-    "level": "critical",
+    "level": "warning",
-    "role": "Mage",
+    "role": "Maya",
-    "problem": "這裡在 DELETE 回傳非 204 時只寫錯誤訊息，沒有把失敗往上拋或標記成整體失敗；同樣的寫法在後面的 tag 刪除區塊也出現一次。最小重現：只要某個 release 因權限不足回 403，step 仍會繼續跑完並以成功結束，外層 workflow 會誤判清理已完成。",
+    "location": "action.yml:40",
-    "suggestion": "把刪除結果納入整體失敗狀態，例如遇到非 204 直接 `throw`，或累積 `hadFailure` 後在流程結束時 `process.exit(1)`，不要讓任何刪除失敗被靜默吞掉。",
+    "problem": "這裡把 action 內注入的 token 改成 `GITEA_TOKEN`，但沒有任何測試去鎖住這個 workflow 契約；只要 YAML 欄位名稱或注入來源寫錯，程式就會默默退回匿名呼叫，錯誤很難被第一時間發現。",
-    "location": "src/index.js:302",
+    "suggestion": "補一個整合測試或 action 介面測試，驗證執行時確實會把 `gitea.token` 帶進 `process.env.GITEA_TOKEN`，且不再依賴舊的 `RUNNER_TOKEN` 輸入。",
-    "is_new": false
-  },
-  {
-    "level": "critical",
-    "role": "Assassin",
-    "location": "src/index.js:299",
-    "problem": "這裡把 `GITEA_SERVER_URL` 直接拼進帶有 `Authorization: token ...` 的 API 請求，只檢查是不是 `https` 並不能防止攻擊者把環境變數指到自己的 HTTPS 主機。只要外部能影響這個值，就能把 runner token 一起送出，等於把這個 action 變成可用來外洩憑證的 SSRF 入口。",
-    "suggestion": "不要只驗證協定，必須把目標主機固定在預期的 Gitea 來源；改成解析 `URL` 後比對 `origin`/host 白名單，拒絕任何非預期網域，並且只在確認是可信任的 Gitea 站台時才附加 `Authorization` header。",
     "is_new": true
   },
   {
     "level": "warning",
-    "role": "Mage",
+    "role": "Maya",
-    "problem": "這裡先抓一份 release 快照，再在後面依這份快照去刪 tag；兩個步驟之間不是同一個時間點。最小重現：cleanup 跑到一半時剛好有人新增 release，新 release 的 tag 來不及出現在 `releaseTags`，接下來的 tag 清理就可能把剛發布的 tag 誤刪。",
+    "location": "src/index.js:426",
-    "suggestion": "把 release 與 tag 的判定建立在同一個一致性快照上，或在刪 tag 前重新驗證該 tag 目前是否已被任何 release 使用；如果環境允許，最好加上流程鎖避免與發版同時執行。",
+    "problem": "有 token 時會改成記錄 redacted 訊息並建立 `Authorization` header，但目前看不到任何測試在保護這個授權分支；一旦 header 格式或遮蔽輸出出錯，就可能讓 API 請求失敗或把敏感值寫進 log。",
-    "location": "src/index.js:312",
+    "suggestion": "補一個有 token 的案例，驗證 log 只會出現 `[redacted]`，而實際送出的 header 會是 `token ${GITEA_TOKEN}`，同時不要把明文 token 暴露到輸出中。",
-    "is_new": false
-  },
-  {
-    "level": "warning",
-    "role": "Rogue",
-    "problem": "這裡又對 releases API 做一次完整 `fetchAllPages()`，前面第 267 行已經抓過同一份資料並排序；等於把整個分頁抓取、JSON 解析與記憶體配置再跑一遍，資料量越大越浪費。",
-    "suggestion": "直接沿用前一次抓到的 `releaseJson`，或先從第一次結果算出要保留的 tag 集合，避免第二次全量拉取。",
-    "location": "src/index.js:312",
-    "is_new": false
-  },
-  {
-    "level": "warning",
-    "role": "Rogue",
-    "problem": "tag 刪除同樣是逐筆 `await`，當 tag 數量多時會把每次 API 往返都串成排隊，刪除時間幾乎全卡在網路延遲上。",
-    "suggestion": "用受限並行處理 tag 刪除，或先收集待刪清單再批次送出，減少總等待時間。",
-    "location": "src/index.js:326",
-    "is_new": false
-  },
-  {
-    "level": "warning",
-    "role": "Assassin",
-    "location": "Dockerfile:8",
-    "problem": "這裡仍然使用可浮動的 `node:22-alpine` 標籤，沒有鎖定到不可變的 digest。攻擊者只要污染上游映像或讓標籤漂移，就可能在 action 啟動前先取得執行權，進而竊取後續流程中的 token 與 repo 資料。",
-    "suggestion": "把基底映像改成固定 digest，例如 `node:22-alpine@sha256:...`，並定期以受控流程更新；不要依賴會隨時間變動的映像標籤。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Leo",
-    "location": "src/index.js:1",
-    "problem": "這個檔案同時承擔 log 格式化、輸入驗證、HTTP 呼叫、分頁抓取、刪除流程與錯誤彙總，責任切得太散。半年後只要想改一個 API 規則，維護者就得在同一個大檔裡來回跳，單元測試也很難把純邏輯跟 I/O 分開。",
-    "suggestion": "把共用基礎能力拆成獨立模組，例如 `logger`、`gitea client`、`cleanup workflow`，並讓主程式只負責組裝依賴與啟動流程。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Mage",
-    "location": "src/index.js:177",
-    "problem": "這裡直接拒絕 `http:` 連線，導致任何使用 `http://` 的 Gitea 部署都會在第一個 API 請求就失敗。最小重現情境是把 `GITEA_SERVER_URL` 設成內網常見的 `http://gitea.local`，整個清理流程會完全無法執行。",
-    "suggestion": "若這個 action 需要支援常見的自架環境，應移除固定只允許 HTTPS 的限制，或把協定限制做成可配置；若確實只支援 HTTPS，也要在 action 說明中明確標示，避免使用者在 `http` 環境下直接踩雷。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Mage",
-    "location": "src/index.js:353",
-    "problem": "前面只要有任何 release 刪除失敗，這裡仍然會繼續做 tag 清理，而且 `releaseTags` 是依照刪除前的清單算出來的。最小重現情境是某個待刪 release 因權限不足或暫時性網路錯誤沒刪掉，接著它對應的 tag 仍可能被刪除，最後變成 release 還在、tag 卻被移除的半套狀態。",
-    "suggestion": "在進入 tag 清理前先檢查 release 刪除是否有失敗；只要有失敗就應中止後續 tag 刪除，或改成只把實際成功刪除的 release 對應 tag 納入待刪集合，避免留下不一致狀態。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Rogue",
-    "location": "src/index.js:25",
-    "problem": "每次輸出一條 log 都要跑 `Intl.DateTimeFormat.formatToParts()`，還額外建立 `lookup` 物件再組字串；這條熱路徑會在每個 release、tag 與錯誤訊息上重複消耗 CPU，訊息一多就很浪費。",
-    "suggestion": "把時間格式改成可快取的字串產生方式，例如同一秒共用結果，或改用較便宜的 formatter，不要每條 log 都做 `formatToParts()` 拆解。",
-    "is_new": true
-  },
-  {
-    "level": "warning",
-    "role": "Rogue",
-    "location": "src/index.js:184",
-    "problem": "這裡先把每一頁資料全部塞進 `all`，等於把整個 API 結果完整具現化；release/tag 數量一大時，記憶體會吃到 O(n)，而且陣列反覆擴容與拷貝也會多耗 CPU。",
-    "suggestion": "改成邊抓邊處理，不要先合併成單一大陣列；如果 API 支援，順便加大每頁筆數，減少往返次數。",
     "is_new": true
   }
 ]

action.yml

@@ -1,5 +1,5 @@
 # 檔案用途：定義 CLEANUP OLD RELEASES 這個 Docker action 的輸入參數與執行環境
-# 更新日期：2026/07/11 21:02:25
+# 更新日期：2026/07/15 11:17:00
 
 # Action 名稱，會顯示在 action 市集與文件中
 name: 'CLEANUP OLD RELEASES'
@@ -12,10 +12,6 @@ author: 'Jeffery'
 
 # 定義可由使用者或呼叫端傳入的輸入參數
 inputs:
-  # RUNNER_TOKEN 用於授權呼叫 Gitea API；未提供時會改用 secrets
-  RUNNER_TOKEN:
-    # 參數說明，讓呼叫端知道這是 Runner Token
-    description: 'Gitea Runner Token'
   # KEEP_COUNT 用於控制保留的 release 數量
   KEEP_COUNT:
     # 參數說明，這裡表示保留的版本數量
@@ -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,5 +1,10 @@
 const https = require('https');
 
+const DELETE_CONCURRENCY = 4;
+const DEFAULT_MAX_PAGES = 1000;
+
+const keepAliveAgent = new https.Agent({ keepAlive: true });
+
 const taipeiFormatter = new Intl.DateTimeFormat('en-CA', {
   timeZone: 'Asia/Taipei',
   year: 'numeric',
@@ -12,6 +17,8 @@ const taipeiFormatter = new Intl.DateTimeFormat('en-CA', {
 });
 
 let currentStage = '';
+let cachedTimestampKey = '';
+let cachedTimestampValue = '';
 
 /**
  * 格式化台灣時區時間，供 log 使用。
@@ -20,6 +27,11 @@ let currentStage = '';
  * @returns {string} `yyyy/MM/dd HH:mm:ss` 格式時間字串。
  */
 function formatTaipeiTimestamp(date = new Date()) {
+  const timestampKey = date.toISOString().slice(0, 19);
+  if (timestampKey === cachedTimestampKey) {
+    return cachedTimestampValue;
+  }
+
   const parts = taipeiFormatter.formatToParts(date);
 
   const lookup = {};
@@ -29,7 +41,9 @@ function formatTaipeiTimestamp(date = new Date()) {
     }
   }
 
-  return `${lookup.year}/${lookup.month}/${lookup.day} ${lookup.hour}:${lookup.minute}:${lookup.second}`;
+  cachedTimestampKey = timestampKey;
+  cachedTimestampValue = `${lookup.year}/${lookup.month}/${lookup.day} ${lookup.hour}:${lookup.minute}:${lookup.second}`;
+  return cachedTimestampValue;
 }
 
 /**
@@ -133,7 +147,31 @@ function fail(message) {
  * @returns {boolean} 如果是空值則回傳 `true`。
  */
 function isEmptyOrNull(value) {
-  return value === undefined || value === null || value === '' || value === 'null';
+  return value === undefined || value === null || value === '';
+}
+
+/**
+ * 正規化環境變數值；workflow 模板缺值時可能代入字面值 `'null'`，一律視為未提供。
+ *
+ * @param {string | undefined} value 環境變數原始值。
+ * @returns {string | undefined} 正規化後的值。
+ */
+function normalizeEnvValue(value) {
+  return value === 'null' ? undefined : value;
+}
+
+/**
+ * 將 URL 遮罩成只含 origin 的文字，供 log 使用。
+ *
+ * @param {*} value 原始 URL 值。
+ * @returns {string} 遮罩後的 origin，無法解析時回傳提示文字。
+ */
+function maskUrlForLog(value) {
+  try {
+    return new URL(String(value)).origin;
+  } catch (error) {
+    return '[invalid URL]';
+  }
 }
 
 /**
@@ -141,9 +179,10 @@ function isEmptyOrNull(value) {
  *
  * @param {string} name 參數名稱。
  * @param {*} value 參數值。
+ * @param {*} [displayValue=value] 寫進 log 的顯示值，敏感內容可先遮罩。
  */
-function requireValue(name, value) {
+function requireValue(name, value, displayValue = value) {
-  info(`${name}=${value}`);
+  info(`${name}=${displayValue}`);
 
   if (isEmptyOrNull(value)) {
     fail(`${name} is required`);
@@ -152,14 +191,52 @@ function requireValue(name, 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);
   }
 }
@@ -168,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:') {
@@ -184,8 +261,19 @@ function request(url, { method = 'GET', headers = {} } = {}) {
       {
         method,
         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');
@@ -194,7 +282,7 @@ function request(url, { method = 'GET', headers = {} } = {}) {
         });
         res.on('end', () => {
           resolve({
-            statusCode: res.statusCode || 0,
+            statusCode,
             body: chunks.join(''),
           });
         });
@@ -207,16 +295,21 @@ function request(url, { method = 'GET', headers = {} } = {}) {
 }
 
 /**
- * 逐頁抓取 JSON 陣列資料，直到回傳空頁為止。
+ * 逐頁抓取 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 > maxPages) {
+      throw new Error(`GET ${baseUrl} 分頁超過 ${maxPages} 頁上限，中止抓取以避免無限迴圈；資料量更大時可用 MAX_PAGES 環境變數調高上限`);
+    }
+
     const pageUrl = `${baseUrl}?page=${page}`;
     const { statusCode, body } = await request(pageUrl, { headers });
 
@@ -256,51 +349,99 @@ 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;
+}
+
+/**
+ * 彙總批次結果；記錄被 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 清理流程。
  */
 async function main() {
-  const { GITEA_SERVER_URL, GITEA_REPOSITORY, RUNNER_TOKEN = '', KEEP_COUNT = '' } =
+  const GITEA_SERVER_URL = normalizeEnvValue(process.env.GITEA_SERVER_URL);
-    process.env;
+  const GITEA_REPOSITORY = normalizeEnvValue(process.env.GITEA_REPOSITORY);
+  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);
+  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 releaseApiUrl = `${GITEA_SERVER_URL}/api/v1/repos/${GITEA_REPOSITORY}/releases`;
+  const serverBase = new URL(GITEA_SERVER_URL);
+  serverBase.username = '';
+  serverBase.password = '';
+  serverBase.search = '';
+  serverBase.hash = '';
+  const serverBaseUrl = serverBase.toString().replace(/\/+$/, '');
+
+  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;
@@ -317,35 +458,39 @@ async function main() {
   info(`RELEASE_COUNT=${releaseCount}`);
   info(`KEEP_COUNT=${KEEP_COUNT}`);
 
-  let hadFailure = false;
-
   if (releaseCount <= keepCount) {
     info('沒有需要清理的舊版本成品');
   } else {
     section('刪除舊版本成品');
 
     const releaseToDelete = releaseJson.slice(keepCount);
-    await processInBatches(releaseToDelete, 4, async (releaseItem) => {
+    const releaseResults = await processInBatches(releaseToDelete, DELETE_CONCURRENCY, async (releaseItem) => {
-      if (!releaseItem || isEmptyOrNull(releaseItem.id)) {
+      const releaseId = releaseItem?.id;
-        warn(
+      if (!Number.isSafeInteger(releaseId) || releaseId <= 0) {
-          `略過沒有 id 的成品: ${sanitizeLogText(releaseItem?.tag_name || '')} (${sanitizeLogText(releaseItem?.name || '')})`,
+        fail(
+          `成品 id 不是正整數，視為資料異常: ${sanitizeLogText(releaseItem?.tag_name || '')} (${sanitizeLogText(releaseItem?.name || '')})`,
         );
-        return;
+        return false;
       }
 
       const releaseTag = sanitizeLogText(releaseItem.tag_name || '');
       const releaseName = sanitizeLogText(releaseItem.name || '');
-      const deleteUrl = `${releaseApiUrl}/${releaseItem.id}`;
+      const deleteUrl = `${releaseApiUrl}/${releaseId}`;
       info(`DELETE ${releaseTag} (${releaseName})`);
 
       const { statusCode } = await deleteResource(deleteUrl, authHeaders);
       if (statusCode === 204) {
         info(`成功刪除: ${releaseTag} (${releaseName})`);
-      } else {
+        return true;
-        hadFailure = true;
-        fail(`刪除失敗: ${releaseTag} (${releaseName}), HTTP ${statusCode}`);
       }
+
+      fail(`刪除失敗: ${releaseTag} (${releaseName}), HTTP ${statusCode}`);
+      return false;
     });
+
+    if (hasBatchFailure(releaseResults)) {
+      throw new Error('至少有一筆 release 刪除失敗');
+    }
   }
 
   section('刪除未指定 release 的 tag');
@@ -357,23 +502,23 @@ async function main() {
       .filter((tag) => !isEmptyOrNull(tag)),
   );
 
-  const tagApiUrl = `${GITEA_SERVER_URL}/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, 4, 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)}`;
@@ -382,19 +527,24 @@ 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('至少有一筆 release 或 tag 刪除失敗');
+    throw new Error('至少有一筆 tag 刪除失敗');
   }
 }
 
-main().catch((error) => {
+main()
-  currentStage = '';
+  .catch((error) => {
-  fail(error instanceof Error ? error.stack || error.message : String(error));
+    const showStack = process.env.RUNNER_DEBUG === '1';
-  process.exit(1);
+    fail(error instanceof Error ? (showStack && error.stack) || error.message : String(error));
-});
+    process.exitCode = 1;
+  })
+  .finally(() => {
+    keepAliveAgent.destroy();
+  });