Zackriya-Solutions/meetily · info · Error

Update check already in progress

Error message

Update check already in progress

What it means

UpdateService.checkForUpdates uses the updateCheckInProgress boolean to prevent overlapping network checks and throws this guard error on re-entry — it is not a network failure. It fires when a second caller invokes checkForUpdates while the first await on the update endpoint is still pending. The guard throws rather than returning the in-flight promise, so every caller must either prevent the second call or catch this exact message.

Source

Thrown at frontend/src/services/updateService.ts:44

/**
 * Update Service
 * Singleton service for managing app updates
 */
export class UpdateService {
  private updateCheckInProgress = false;
  private lastCheckTime: number | null = null;
  private readonly CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours

  /**
   * Check for available updates
   * @param force Force check even if recently checked
   * @returns Promise with update information
   */
  async checkForUpdates(force = false): Promise<UpdateInfo> {
    // Prevent concurrent update checks
    if (this.updateCheckInProgress) {
      throw new Error('Update check already in progress');
    }

    // Skip if checked recently (unless forced)
    if (!force && this.lastCheckTime) {
      const timeSinceLastCheck = Date.now() - this.lastCheckTime;
      if (timeSinceLastCheck < this.CHECK_INTERVAL_MS) {
        console.log('Skipping update check - checked recently');
        return {
          available: false,
          currentVersion: await getVersion(),
        };
      }
    }

    this.updateCheckInProgress = true;
    this.lastCheckTime = Date.now();

    try {

View on GitHub (pinned to 0281737d87)

Solutions

  1. Short-circuit callers: check the in-progress flag (expose a getter) or disable the button while a check runs.
  2. In React StrictMode dev runs, guard the mount-time call with a ref so the double-mount doesn't issue two checks.
  3. Refactor checkForUpdates to memoize and return the in-flight promise instead of throwing (see exampleFix) — the cleanest fix.
  4. Catch this specific message in callers and treat it as a no-op, not an error toast.

Example fix

// before
if (this.updateCheckInProgress) {
  throw new Error('Update check already in progress');
}

// after — share the in-flight promise instead of throwing
private inFlight: Promise<UpdateInfo> | null = null;
async checkForUpdates(force = false): Promise<UpdateInfo> {
  if (!force && this.inFlight) return this.inFlight;
  const p = this.doCheck(force).finally(() => { this.inFlight = null; });
  this.inFlight = p;
  return p;
}
Defensive patterns

Strategy: validation

Validate before calling

// expose state on the service
get isChecking() { return this.updateCheckInProgress; }

// caller
if (updateService.isChecking) return; // a check is already running
await updateService.checkForUpdates(true);

Try / catch

try {
  await updateService.checkForUpdates(true);
} catch (e) {
  if (e instanceof Error && e.message === 'Update check already in progress') return; // benign re-entry
  throw e;
}

Prevention

When it happens

Trigger: App-startup automatic check racing a manual 'Check for updates' button click; React StrictMode double-invoking the effect that calls checkForUpdates in development; two components mounting and both calling it on load.

Common situations: React 18 StrictMode double-mount in dev, a settings page and a startup hook both polling, or a user double-clicking the update button before it disables itself.

Related errors

AI-assisted analysis of Zackriya-Solutions/meetily@0281737d87 (2026-08-16). Data as JSON: /api/errors/4f2307f22efc7922. Report an issue: GitHub.