recover interrupted checks and harden popup check flow

- recover stale `checkInProgress` state after service worker restart/interruption
- mark interrupted checks as failed with a clear message instead of leaving popup stuck on "Checking now..."
- refresh popup state in a safe `try/finally` flow when `Check now` is triggered
- add tests for interrupted runtime-state recovery

This fixes the case where the popup could remain blocked after a background check was interrupted or the message flow between popup and service worker was broken.

Author: Grim1313

src/lib/promotions.js

@@ -34,13 +34,28 @@ import {
 } from "./history.js";
 import { createPromotionNotifications } from "./notifications.js";
 import { fetchPromotionsFromProviders } from "./providers/index.js";
-import { getRuntimeState, setRuntimeState } from "./runtime-state.js";
+import { buildRecoveredRuntimeState, getRuntimeState, setRuntimeState } from "./runtime-state.js";
 import { getSettings } from "./settings.js";
 import { readKey, writeLocal } from "./storage.js";
 import { createHash, isQuietHoursActive } from "./utils.js";
 
 let activeCheckPromise = null;
 
+export async function recoverInterruptedCheckState(nowTs = Date.now()) {
+  if (activeCheckPromise) {
+    return getRuntimeState();
+  }
+
+  const runtimeState = await getRuntimeState();
+  if (!runtimeState.checkInProgress) {
+    return runtimeState;
+  }
+
+  const recoveredState = buildRecoveredRuntimeState(runtimeState, nowTs);
+  await writeLocal({ [STORAGE_KEYS.runtimeState]: recoveredState });
+  return recoveredState;
+}
+
 function getPromotionMatchKey(promotion) {
   const stableId = typeof promotion?.stableId === "string" ? promotion.stableId : "";
   const promoType = typeof promotion?.promoType === "string" ? promotion.promoType : "";

src/lib/runtime-state.js

@@ -2,6 +2,8 @@ import { STORAGE_KEYS } from "./constants.js";
 import { readKey, writeLocal } from "./storage.js";
 import { clamp, safeNumber } from "./utils.js";
 
+export const INTERRUPTED_CHECK_MESSAGE = "Previous check was interrupted. Run Check now again.";
+
 export const DEFAULT_RUNTIME_STATE = Object.freeze({
   checkInProgress: false,
   lastCheckStartedAt: 0,
@@ -41,6 +43,21 @@ export function sanitizeRuntimeState(raw = {}) {
   };
 }
 
+export function buildRecoveredRuntimeState(raw = {}, nowTs = Date.now()) {
+  const runtimeState = sanitizeRuntimeState(raw);
+  if (!runtimeState.checkInProgress) {
+    return runtimeState;
+  }
+
+  return sanitizeRuntimeState({
+    ...runtimeState,
+    checkInProgress: false,
+    lastCheckFinishedAt: Math.max(runtimeState.lastCheckFinishedAt, safeNumber(nowTs, 0)),
+    lastCheckOutcome: "error",
+    lastErrorMessage: runtimeState.lastErrorMessage || INTERRUPTED_CHECK_MESSAGE
+  });
+}
+
 export async function getRuntimeState() {
   const stored = await readKey(STORAGE_KEYS.runtimeState, DEFAULT_RUNTIME_STATE);
   return sanitizeRuntimeState(stored);

src/service-worker.js

@@ -7,6 +7,7 @@ import {
   dismissPromotionById,
   getIgnoredPromotions,
   markAllPromotionsRead,
+  recoverInterruptedCheckState,
   restorePromotionById,
   runPromotionCheck
 } from "./lib/promotions.js";
@@ -23,7 +24,7 @@ import {
 async function bootstrap() {
   await ensureSchemaVersion();
   const settings = await getSettings();
-  const runtimeState = await getRuntimeState();
+  const runtimeState = await recoverInterruptedCheckState();
 
   const [historyEntries, latestPromotions] = await Promise.all([
     getHistoryEntries(),
@@ -77,7 +78,7 @@ async function runAndReschedule(trigger) {
 async function getPopupData() {
   const [settings, runtimeState, latestPromotions] = await Promise.all([
     getSettings(),
-    getRuntimeState(),
+    recoverInterruptedCheckState(),
     getLatestPromotionEntries()
   ]);
   return {
@@ -91,7 +92,7 @@ async function getPopupData() {
 async function getOptionsData() {
   const [settings, runtimeState, ignoredPromotions] = await Promise.all([
     getSettings(),
-    getRuntimeState(),
+    recoverInterruptedCheckState(),
     getIgnoredPromotions()
   ]);
   return {
@@ -105,7 +106,7 @@ async function getOptionsData() {
 async function getHistoryData() {
   const [settings, runtimeState, historyEntries, latestPromotions, ignoredPromotions] = await Promise.all([
     getSettings(),
-    getRuntimeState(),
+    recoverInterruptedCheckState(),
     getHistoryEntries(),
     getLatestPromotionEntries(),
     getIgnoredPromotions()

src/ui/popup.js

@@ -158,11 +158,21 @@ async function refresh(temporaryWarning = "") {
 checkNowButton.addEventListener("click", async () => {
   checkNowButton.disabled = true;
   statusText.textContent = "Checking now...";
-  const response = await sendMessage("CHECK_NOW");
-  if (!response?.ok) {
-    renderWarning(response?.error || "Manual check failed.");
+  try {
+    const response = await sendMessage("CHECK_NOW");
+    if (!response?.ok) {
+      renderWarning(response?.error || "Manual check failed.");
+    }
+  } catch (error) {
+    renderWarning(error instanceof Error ? error.message : "Manual check failed.");
+  } finally {
+    try {
+      await refresh();
+    } catch (error) {
+      checkNowButton.disabled = false;
+      renderWarning(error instanceof Error ? error.message : String(error));
+    }
   }
-  await refresh();
 });
 
 optionsLink.addEventListener("click", async (event) => {

tests/runtime-state.test.js

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildRecoveredRuntimeState, INTERRUPTED_CHECK_MESSAGE } from "../src/lib/runtime-state.js";
+
+test("buildRecoveredRuntimeState clears a stale in-progress check", () => {
+  const recovered = buildRecoveredRuntimeState({
+    checkInProgress: true,
+    lastCheckStartedAt: 100,
+    lastCheckFinishedAt: 0,
+    lastCheckOutcome: "running",
+    lastErrorMessage: "",
+    unreadCount: 3
+  }, 250);
+
+  assert.equal(recovered.checkInProgress, false);
+  assert.equal(recovered.lastCheckOutcome, "error");
+  assert.equal(recovered.lastCheckFinishedAt, 250);
+  assert.equal(recovered.lastErrorMessage, INTERRUPTED_CHECK_MESSAGE);
+  assert.equal(recovered.unreadCount, 3);
+});
+
+test("buildRecoveredRuntimeState keeps settled checks unchanged", () => {
+  const recovered = buildRecoveredRuntimeState({
+    checkInProgress: false,
+    lastCheckFinishedAt: 100,
+    lastCheckOutcome: "success",
+    lastErrorMessage: ""
+  }, 250);
+
+  assert.equal(recovered.checkInProgress, false);
+  assert.equal(recovered.lastCheckOutcome, "success");
+  assert.equal(recovered.lastCheckFinishedAt, 100);
+  assert.equal(recovered.lastErrorMessage, "");
+});