ccstatusline 2.2.24 → 2.2.25

package/dist/ccstatusline.js

@@ -55594,12 +55594,18 @@ var init_GitUntrackedFiles = __esm(() => {
 });
 
 // src/utils/git-review-cache.ts
-import { execFileSync as execFileSync2 } from "child_process";
 import {
+  execFileSync as execFileSync2,
+  spawn
+} from "child_process";
+import {
+  closeSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
+  openSync,
   readFileSync as readFileSync3,
   statSync as statSync2,
+  unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { createHash as createHash2 } from "node:crypto";
@@ -55689,35 +55695,66 @@ function getCachePath2(cwd2, ref, deps) {
   const hash2 = createHash2("sha256").update(cwd2).update("\x00").update(ref).digest("hex").slice(0, 16);
   return path2.join(getGitReviewCacheDir(deps), `git-review-${hash2}.json`);
 }
+function isGitReviewData(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.number === "number" && typeof candidate.url === "string";
+}
+function decodeCache(content) {
+  if (content.length === 0) {
+    return { data: null, checksQueried: true };
+  }
+  const parsed = JSON.parse(content);
+  if (typeof parsed === "object" && parsed !== null) {
+    const stored = parsed;
+    if (stored.version === 1 && typeof stored.checksQueried === "boolean" && (stored.data === null || isGitReviewData(stored.data))) {
+      return {
+        data: stored.data,
+        checksQueried: stored.data === null || stored.checksQueried
+      };
+    }
+  }
+  if (isGitReviewData(parsed)) {
+    return {
+      data: parsed,
+      checksQueried: parsed.checks !== undefined
+    };
+  }
+  return "miss";
+}
 function readCache(cachePath, deps) {
   try {
     if (!deps.existsSync(cachePath)) {
       return "miss";
     }
     const age = deps.now() - deps.statSync(cachePath).mtimeMs;
-    if (age > GIT_REVIEW_CACHE_TTL) {
-      return "miss";
-    }
     const content = deps.readFileSync(cachePath, "utf-8").trim();
-    if (content.length === 0) {
-      return null;
-    }
-    const data = JSON.parse(content);
-    if (typeof data.number !== "number" || typeof data.url !== "string") {
+    const decoded = decodeCache(content);
+    if (decoded === "miss") {
       return "miss";
     }
-    return data;
+    return {
+      ...decoded,
+      stale: age > GIT_REVIEW_CACHE_TTL
+    };
   } catch {
     return "miss";
   }
 }
-function writeCache(cachePath, data, deps) {
+function writeCache(cachePath, data, checksQueried, deps) {
   try {
     const cacheDir = getGitReviewCacheDir(deps);
     if (!deps.existsSync(cacheDir)) {
       deps.mkdirSync(cacheDir, { recursive: true });
     }
-    deps.writeFileSync(cachePath, data ? JSON.stringify(data) : "", "utf-8");
+    const stored = {
+      version: 1,
+      data,
+      checksQueried: data === null || checksQueried
+    };
+    deps.writeFileSync(cachePath, JSON.stringify(stored), "utf-8");
   } catch {}
 }
 function getOriginUrl(cwd2, deps) {
@@ -55798,11 +55835,18 @@ function getProviderCandidates(cwd2, deps) {
   }
   return authed;
 }
-function isCliAvailable(cli, deps) {
+function getRemainingTimeout(deadline, deps) {
+  const remaining = deadline - deps.now();
+  if (remaining <= 0) {
+    throw new GitReviewDeadlineError("Git review lookup deadline exceeded");
+  }
+  return Math.max(1, Math.min(CLI_TIMEOUT, remaining));
+}
+function isCliAvailable(cli, deadline, deps) {
   try {
     deps.execFileSync(cli, ["--version"], {
       stdio: ["pipe", "pipe", "ignore"],
-      timeout: CLI_TIMEOUT,
+      timeout: getRemainingTimeout(deadline, deps),
       windowsHide: true
     });
     return true;
@@ -55833,12 +55877,25 @@ function mapGlabState(state) {
     return "LOCKED";
   return state.toUpperCase();
 }
-function queryGhPr(cwd2, args, fields, deps) {
+function errorText(error51) {
+  if (!(error51 instanceof Error)) {
+    return "";
+  }
+  const stderr = "stderr" in error51 ? error51.stderr : undefined;
+  const stderrText = Buffer.isBuffer(stderr) ? stderr.toString("utf8") : stderr ?? "";
+  return `${error51.message}
+${stderrText}`.toLowerCase();
+}
+function isCiFieldUnavailableError(error51) {
+  const text = errorText(error51);
+  return text.includes("statuscheckrollup") || text.includes("resource not accessible by integration");
+}
+function queryGhPr(cwd2, args, fields, deadline, deps) {
   const output = deps.execFileSync("gh", [...args, "--json", fields], {
     encoding: "utf8",
-    stdio: ["pipe", "pipe", "ignore"],
+    stdio: ["pipe", "pipe", "pipe"],
     cwd: cwd2,
-    timeout: CLI_TIMEOUT,
+    timeout: getRemainingTimeout(deadline, deps),
     windowsHide: true
   }).trim();
   if (output.length === 0) {
@@ -55846,7 +55903,7 @@ function queryGhPr(cwd2, args, fields, deps) {
   }
   return JSON.parse(output);
 }
-function fetchFromGh(cwd2, repoRef, deps) {
+function fetchFromGh(cwd2, repoRef, includeChecks, deadline, deps) {
   const args = ["pr", "view"];
   if (repoRef) {
     const branch = getCurrentBranch(cwd2, deps);
@@ -55856,10 +55913,17 @@ function fetchFromGh(cwd2, repoRef, deps) {
     args.push(branch, "--repo", repoRef);
   }
   let parsed;
-  try {
-    parsed = queryGhPr(cwd2, args, GH_PR_WITH_CHECKS_FIELDS, deps);
-  } catch {
-    parsed = queryGhPr(cwd2, args, GH_PR_METADATA_FIELDS, deps);
+  if (includeChecks) {
+    try {
+      parsed = queryGhPr(cwd2, args, GH_PR_WITH_CHECKS_FIELDS, deadline, deps);
+    } catch (error51) {
+      if (!isCiFieldUnavailableError(error51)) {
+        throw error51;
+      }
+      parsed = queryGhPr(cwd2, args, GH_PR_METADATA_FIELDS, deadline, deps);
+    }
+  } else {
+    parsed = queryGhPr(cwd2, args, GH_PR_METADATA_FIELDS, deadline, deps);
   }
   if (!parsed) {
     return null;
@@ -55877,7 +55941,7 @@ function fetchFromGh(cwd2, repoRef, deps) {
     checks: computeCiRollup(parsed.statusCheckRollup) ?? undefined
   };
 }
-function fetchFromGlab(cwd2, repoRef, deps) {
+function fetchFromGlab(cwd2, repoRef, deadline, deps) {
   const args = ["mr", "view"];
   if (repoRef) {
     const branch = getCurrentBranch(cwd2, deps);
@@ -55891,7 +55955,7 @@ function fetchFromGlab(cwd2, repoRef, deps) {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "ignore"],
     cwd: cwd2,
-    timeout: CLI_TIMEOUT,
+    timeout: getRemainingTimeout(deadline, deps),
     windowsHide: true
   }).trim();
   if (output.length === 0) {
@@ -55910,41 +55974,129 @@ function fetchFromGlab(cwd2, repoRef, deps) {
     provider: "glab"
   };
 }
-function fetchFromProvider(provider, cwd2, repoRef, deps) {
-  const fetchFn = provider === "gh" ? fetchFromGh : fetchFromGlab;
+function fetchFromProvider(provider, cwd2, repoRef, includeChecks, deadline, deps) {
+  const fetch2 = (targetRepoRef) => provider === "gh" ? fetchFromGh(cwd2, targetRepoRef, includeChecks, deadline, deps) : fetchFromGlab(cwd2, targetRepoRef, deadline, deps);
   try {
-    const unpinned = fetchFn(cwd2, null, deps);
+    const unpinned = fetch2(null);
     if (unpinned) {
       return unpinned;
     }
   } catch {}
   if (repoRef) {
-    return fetchFn(cwd2, repoRef, deps);
+    return fetch2(repoRef);
   }
   return null;
 }
-function fetchGitReviewData(cwd2, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
+function fetchGitReviewData(cwd2, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS, options = {}) {
+  const includeChecks = options.includeChecks ?? false;
   const cachePath = getCachePath2(cwd2, getCacheRef(cwd2, deps), deps);
   const cached2 = readCache(cachePath, deps);
-  if (cached2 !== "miss") {
-    return cached2;
+  if (cached2 !== "miss" && !cached2.stale && (!includeChecks || cached2.checksQueried)) {
+    return cached2.data;
   }
   const repoRef = getOriginRepoRef(cwd2, deps);
+  const deadline = deps.now() + CLI_TIMEOUT;
   for (const provider of getProviderCandidates(cwd2, deps)) {
-    if (!isCliAvailable(provider, deps)) {
+    if (!isCliAvailable(provider, deadline, deps)) {
       continue;
     }
     try {
-      const data = fetchFromProvider(provider, cwd2, repoRef, deps);
+      const data = fetchFromProvider(provider, cwd2, repoRef, includeChecks, deadline, deps);
       if (data) {
-        writeCache(cachePath, data, deps);
+        writeCache(cachePath, data, includeChecks, deps);
         return data;
       }
     } catch {}
   }
-  writeCache(cachePath, null, deps);
+  if (cached2 !== "miss" && cached2.data !== null) {
+    return cached2.data;
+  }
+  writeCache(cachePath, null, true, deps);
   return null;
 }
+function getRefreshLockPath(cachePath) {
+  return `${cachePath}.lock`;
+}
+function releaseRefreshLock(lockPath, deps) {
+  try {
+    deps.unlinkSync(lockPath);
+  } catch {}
+}
+function createRefreshLock(cachePath, deps) {
+  const cacheDir = getGitReviewCacheDir(deps);
+  try {
+    if (!deps.existsSync(cacheDir)) {
+      deps.mkdirSync(cacheDir, { recursive: true });
+    }
+  } catch {
+    return null;
+  }
+  const lockPath = getRefreshLockPath(cachePath);
+  for (let attempt2 = 0;attempt2 < 2; attempt2++) {
+    try {
+      const descriptor = deps.openSync(lockPath, "wx");
+      deps.closeSync(descriptor);
+      return lockPath;
+    } catch {
+      try {
+        const age = deps.now() - deps.statSync(lockPath).mtimeMs;
+        if (age <= REFRESH_LOCK_STALE_MS) {
+          return null;
+        }
+        deps.unlinkSync(lockPath);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function scheduleRefresh(cwd2, cachePath, includeChecks, deps) {
+  const scriptPath = deps.getScriptPath();
+  if (!scriptPath) {
+    return;
+  }
+  const lockPath = createRefreshLock(cachePath, deps);
+  if (!lockPath) {
+    return;
+  }
+  try {
+    const child = deps.spawn(deps.getExecPath(), [
+      scriptPath,
+      GIT_REVIEW_REFRESH_FLAG,
+      cwd2,
+      includeChecks ? "checks" : "metadata",
+      lockPath
+    ], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.unref();
+  } catch {
+    releaseRefreshLock(lockPath, deps);
+  }
+}
+function getCachedGitReviewData(cwd2, options = {}, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
+  const includeChecks = options.includeChecks ?? false;
+  const cachePath = getCachePath2(cwd2, getCacheRef(cwd2, deps), deps);
+  const cached2 = readCache(cachePath, deps);
+  const needsRefresh = cached2 === "miss" || cached2.stale || includeChecks && !cached2.checksQueried;
+  if (needsRefresh) {
+    scheduleRefresh(cwd2, cachePath, includeChecks, deps);
+  }
+  return cached2 === "miss" ? null : cached2.data;
+}
+function refreshGitReviewCacheFromCli(cwd2, options, lockPath, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
+  const expectedLockPath = getRefreshLockPath(getCachePath2(cwd2, getCacheRef(cwd2, deps), deps));
+  try {
+    fetchGitReviewData(cwd2, deps, options);
+  } finally {
+    if (lockPath === expectedLockPath) {
+      releaseRefreshLock(lockPath, deps);
+    }
+  }
+}
 function getGitReviewStatusLabel(state, reviewDecision) {
   if (state === "MERGED")
     return "MERGED";
@@ -55964,20 +56116,28 @@ function truncateTitle(title, maxWidth) {
     return title;
   return `${title.slice(0, limit - 1)}…`;
 }
-var GIT_REVIEW_CACHE_TTL = 30000, CLI_TIMEOUT = 5000, DEFAULT_TITLE_MAX_WIDTH = 30, GH_PR_METADATA_FIELDS = "url,number,title,state,reviewDecision", GH_PR_WITH_CHECKS_FIELDS, DEFAULT_GIT_REVIEW_CACHE_DEPS;
+var GIT_REVIEW_CACHE_TTL = 30000, CLI_TIMEOUT = 5000, REFRESH_LOCK_STALE_MS = 30000, DEFAULT_TITLE_MAX_WIDTH = 30, GH_PR_METADATA_FIELDS = "url,number,title,state,reviewDecision", GH_PR_WITH_CHECKS_FIELDS, GIT_REVIEW_REFRESH_FLAG = "--internal-refresh-git-review-cache", DEFAULT_GIT_REVIEW_CACHE_DEPS, GitReviewDeadlineError;
 var init_git_review_cache = __esm(() => {
   init_git_remote();
   GH_PR_WITH_CHECKS_FIELDS = `${GH_PR_METADATA_FIELDS},statusCheckRollup`;
   DEFAULT_GIT_REVIEW_CACHE_DEPS = {
+    closeSync,
     execFileSync: execFileSync2,
     existsSync: existsSync2,
+    getExecPath: () => process.execPath,
     mkdirSync: mkdirSync2,
+    openSync,
     readFileSync: readFileSync3,
+    getScriptPath: () => process.argv[1],
+    spawn,
     statSync: statSync2,
+    unlinkSync,
     writeFileSync: writeFileSync2,
     getHomedir: os4.homedir,
     now: Date.now
   };
+  GitReviewDeadlineError = class GitReviewDeadlineError extends Error {
+  };
 });
 
 // src/widgets/GitCiStatus.ts
@@ -56029,7 +56189,7 @@ class GitCiStatusWidget {
       return isHideNoGitEnabled(item) ? null : "(no git)";
     }
     const cwd2 = this.deps.resolveGitCwd(context) ?? this.deps.getProcessCwd();
-    const checks3 = this.deps.fetchGitReviewData(cwd2)?.checks;
+    const checks3 = this.deps.getCachedGitReviewData(cwd2, { includeChecks: true })?.checks;
     if (!checks3) {
       return NO_CHECKS;
     }
@@ -56057,7 +56217,7 @@ var init_GitCiStatus = __esm(() => {
     pending: "●"
   };
   DEFAULT_DEPS = {
-    fetchGitReviewData,
+    getCachedGitReviewData,
     getProcessCwd: () => process.cwd(),
     isInsideGitWorkTree,
     resolveGitCwd
@@ -56334,7 +56494,7 @@ class GitPrWidget {
       return hideNoGit ? null : `(no ${resolvePrNoun(null, context, this.deps)})`;
     }
     const cwd2 = this.deps.resolveGitCwd(context) ?? this.deps.getProcessCwd();
-    const prData = this.deps.fetchGitReviewData(cwd2);
+    const prData = this.deps.getCachedGitReviewData(cwd2, { includeChecks: context.gitReviewNeedsChecks ?? false });
     if (!prData) {
       return hideNoGit ? null : `(no ${resolvePrNoun(null, context, this.deps)})`;
     }
@@ -56362,7 +56522,7 @@ var init_GitPr = __esm(() => {
   init_hyperlink();
   init_git_no_git();
   DEFAULT_GIT_PR_WIDGET_DEPS = {
-    fetchGitReviewData,
+    getCachedGitReviewData,
     getProcessCwd: () => process.cwd(),
     getRemoteInfo,
     isInsideGitWorkTree,
@@ -58127,7 +58287,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.24";
+var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.25";
 var init_terminal = () => {};
 
 // src/utils/format-tokens.ts
@@ -79925,6 +80085,7 @@ var StatusJSONSchema = exports_external.looseObject({
 init_ansi();
 init_colors();
 init_compaction();
+init_git_review_cache();
 await init_config();
 
 // src/utils/hook-handler.ts
@@ -80286,7 +80447,8 @@ async function renderMultipleLines(data) {
     terminalWidth: getTerminalWidth(),
     isPreview: false,
     minimalist: settings.minimalistMode,
-    gitCacheTtlSeconds: settings.gitCacheTtlSeconds
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
+    gitReviewNeedsChecks: lines.some((line) => line.some((item) => item.type === "git-ci-status"))
   };
   const preRenderedLines = preRenderAllWidgets(lines, settings, context);
   const preCalculatedMaxWidths = calculateMaxWidthsFromPreRendered(preRenderedLines, settings);
@@ -80361,7 +80523,24 @@ async function handleHook() {
   const input = await readStdin();
   handleHookInput(input);
 }
+function handleGitReviewRefresh() {
+  const flagIndex = process.argv.indexOf(GIT_REVIEW_REFRESH_FLAG);
+  if (flagIndex === -1) {
+    return false;
+  }
+  const cwd2 = process.argv[flagIndex + 1];
+  const mode = process.argv[flagIndex + 2];
+  const lockPath = process.argv[flagIndex + 3];
+  if (!cwd2 || mode !== "metadata" && mode !== "checks" || !lockPath) {
+    return true;
+  }
+  refreshGitReviewCacheFromCli(cwd2, { includeChecks: mode === "checks" }, lockPath);
+  return true;
+}
 async function main() {
+  if (handleGitReviewRefresh()) {
+    return;
+  }
   if (process.argv.includes("--version")) {
     console.log(getPackageVersion());
     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccstatusline",
-  "version": "2.2.24",
+  "version": "2.2.25",
   "bugs": {
     "url": "https://github.com/sirmalloc/ccstatusline/issues"
   },