feat(media hosting): disable unreachable providers

src/lib/media-hosting/__tests__/provider-availability.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ensureProviderAvailability, getProviderAvailabilitySnapshot, probeProviderAvailability, resetProviderAvailabilityForTests } from '../provider-availability';
+
+class MockImage {
+  static failedUrlPart = '';
+
+  onload: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  referrerPolicy = '';
+
+  set src(value: string) {
+    queueMicrotask(() => {
+      if (MockImage.failedUrlPart && value.includes(MockImage.failedUrlPart)) {
+        this.onerror?.();
+        return;
+      }
+      this.onload?.();
+    });
+  }
+}
+
+describe('provider-availability', () => {
+  beforeEach(() => {
+    resetProviderAvailabilityForTests();
+    MockImage.failedUrlPart = '';
+    vi.stubGlobal('Image', MockImage);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    resetProviderAvailabilityForTests();
+  });
+
+  it('marks runtime-supported providers available when probes load', async () => {
+    const snapshot = await ensureProviderAvailability('android');
+
+    expect(snapshot.catbox).toBe('available');
+    expect(snapshot.imgbb).toBe('available');
+    expect(snapshot.imgur).toBe('unknown');
+  });
+
+  it('marks a provider unavailable when one of its media probes fails', async () => {
+    MockImage.failedUrlPart = 'i.ibb.co';
+
+    const status = await probeProviderAvailability('imgbb');
+
+    expect(status).toBe('unavailable');
+    expect(getProviderAvailabilitySnapshot().imgbb).toBe('unavailable');
+  });
+
+  it('leaves providers unknown when image probing is unavailable', async () => {
+    vi.stubGlobal('Image', undefined);
+
+    const status = await probeProviderAvailability('catbox');
+
+    expect(status).toBe('unknown');
+    expect(getProviderAvailabilitySnapshot().catbox).toBe('unknown');
+  });
+});

src/lib/media-hosting/__tests__/provider-order.test.ts

@@ -6,24 +6,25 @@ describe('provider-order', () => {
     it('returns single-element array with preferred provider', () => {
       expect(getPreferredOrder('catbox')).toEqual(['catbox']);
       expect(getPreferredOrder('imgur')).toEqual(['imgur']);
+      expect(getPreferredOrder('imgbb')).toEqual(['imgbb']);
     });
   });
 
   describe('getRandomOrder', () => {
     it('returns shuffled copy (Fisher-Yates) with default rng', () => {
-      const providers = ['catbox', 'imgur'] as const;
+      const providers = ['catbox', 'imgur', 'imgbb'] as const;
       const result = getRandomOrder(providers);
-      expect(result).toHaveLength(2);
-      expect([...result].sort()).toEqual(['catbox', 'imgur']);
+      expect(result).toHaveLength(3);
+      expect([...result].sort()).toEqual(['catbox', 'imgbb', 'imgur']);
       expect(result).not.toBe(providers);
     });
 
     it('uses provided rng for deterministic shuffle', () => {
-      const providers = ['catbox', 'imgur'] as const;
+      const providers = ['catbox', 'imgur', 'imgbb'] as const;
       const rng = vi.fn().mockReturnValue(0.5);
       const result = getRandomOrder(providers, rng);
       expect(rng).toHaveBeenCalled();
-      expect(result).toHaveLength(2);
+      expect(result).toHaveLength(3);
     });
 
     it('handles empty array', () => {
@@ -61,6 +62,13 @@ describe('provider-order', () => {
           runtime: 'electron',
         }),
       ).toEqual(['imgur']);
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgbb',
+          runtime: 'android',
+        }),
+      ).toEqual(['imgbb']);
     });
 
     it('returns empty when preferred provider not supported on runtime', () => {
@@ -71,6 +79,20 @@ describe('provider-order', () => {
           runtime: 'web',
         }),
       ).toEqual([]);
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgur',
+          runtime: 'android',
+        }),
+      ).toEqual([]);
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgbb',
+          runtime: 'web',
+        }),
+      ).toEqual([]);
     });
 
     it('returns shuffled list when mode is random', () => {
@@ -79,8 +101,30 @@ describe('provider-order', () => {
         preferredProvider: 'catbox',
         runtime: 'electron',
       });
+      expect(order).toHaveLength(3);
+      expect([...order].sort()).toEqual(['catbox', 'imgbb', 'imgur']);
+    });
+
+    it('filters unavailable providers from random mode', () => {
+      const order = getProviderOrder({
+        mode: 'random',
+        preferredProvider: 'catbox',
+        runtime: 'electron',
+        availability: { imgur: 'unavailable' },
+      });
       expect(order).toHaveLength(2);
-      expect([...order].sort()).toEqual(['catbox', 'imgur']);
+      expect([...order].sort()).toEqual(['catbox', 'imgbb']);
+    });
+
+    it('returns empty when preferred provider is unavailable', () => {
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgbb',
+          runtime: 'android',
+          availability: { imgbb: 'unavailable' },
+        }),
+      ).toEqual([]);
     });
 
     it('filters by runtime for random mode', () => {
@@ -92,5 +136,15 @@ describe('provider-order', () => {
       expect(order).toHaveLength(1);
       expect(order).toEqual(['catbox']);
     });
+
+    it('uses catbox and imgbb for android random mode', () => {
+      const order = getProviderOrder({
+        mode: 'random',
+        preferredProvider: 'catbox',
+        runtime: 'android',
+      });
+      expect(order).toHaveLength(2);
+      expect([...order].sort()).toEqual(['catbox', 'imgbb']);
+    });
   });
 });

src/lib/media-hosting/provider-availability.ts

@@ -0,0 +1,147 @@
+import { MEDIA_HOSTING_PROVIDERS } from './providers';
+import type { MediaHostingRuntime, ProviderId } from './types';
+
+export type ProviderAvailabilityStatus = 'unknown' | 'checking' | 'available' | 'unavailable';
+export type ProviderAvailabilitySnapshot = Partial<Record<ProviderId, ProviderAvailabilityStatus>>;
+
+const PROBE_TIMEOUT_MS = 5_000;
+const PROBE_CACHE_MS = 10 * 60_000;
+
+type Listener = () => void;
+
+interface ProviderAvailabilityEntry {
+  status: ProviderAvailabilityStatus;
+  checkedAt: number;
+}
+
+const providerById = new Map(MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, provider]));
+let entries: Record<ProviderId, ProviderAvailabilityEntry> = Object.fromEntries(
+  MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, { status: 'unknown', checkedAt: 0 }]),
+) as Record<ProviderId, ProviderAvailabilityEntry>;
+let snapshot: ProviderAvailabilitySnapshot = buildSnapshot();
+const listeners = new Set<Listener>();
+const inFlight = new Map<ProviderId, Promise<ProviderAvailabilityStatus>>();
+
+function buildSnapshot(): ProviderAvailabilitySnapshot {
+  return Object.fromEntries(MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, entries[provider.id]?.status ?? 'unknown'])) as ProviderAvailabilitySnapshot;
+}
+
+function emit() {
+  snapshot = buildSnapshot();
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function setProviderStatus(provider: ProviderId, status: ProviderAvailabilityStatus) {
+  entries = {
+    ...entries,
+    [provider]: {
+      status,
+      checkedAt: status === 'checking' ? entries[provider].checkedAt : Date.now(),
+    },
+  };
+  emit();
+}
+
+function getRuntimeSupportedProviders(runtime: MediaHostingRuntime): ProviderId[] {
+  return MEDIA_HOSTING_PROVIDERS.filter((provider) => provider.supportedRuntimes.includes(runtime)).map((provider) => provider.id);
+}
+
+function shouldProbeProvider(provider: ProviderId): boolean {
+  if (inFlight.has(provider)) return false;
+  const entry = entries[provider];
+  return entry.status === 'unknown' || Date.now() - entry.checkedAt > PROBE_CACHE_MS;
+}
+
+function probeImageUrl(url: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const image = new Image();
+    let settled = false;
+    const timeoutId = window.setTimeout(() => settle(false), PROBE_TIMEOUT_MS);
+
+    const settle = (available: boolean) => {
+      if (settled) return;
+      settled = true;
+      window.clearTimeout(timeoutId);
+      image.onload = null;
+      image.onerror = null;
+      resolve(available);
+    };
+
+    image.onload = () => settle(true);
+    image.onerror = () => settle(false);
+    image.referrerPolicy = 'no-referrer';
+    image.src = url;
+  });
+}
+
+export function getProviderAvailabilitySnapshot(): ProviderAvailabilitySnapshot {
+  return snapshot;
+}
+
+export function subscribeProviderAvailability(listener: Listener, runtime?: MediaHostingRuntime): () => void {
+  listeners.add(listener);
+  if (runtime) {
+    startProviderAvailabilityProbes(runtime);
+  }
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function startProviderAvailabilityProbes(runtime: MediaHostingRuntime) {
+  for (const provider of getRuntimeSupportedProviders(runtime)) {
+    if (shouldProbeProvider(provider)) {
+      void probeProviderAvailability(provider);
+    }
+  }
+}
+
+export async function probeProviderAvailability(provider: ProviderId): Promise<ProviderAvailabilityStatus> {
+  const running = inFlight.get(provider);
+  if (running) return running;
+
+  const definition = providerById.get(provider);
+  if (!definition) return 'unavailable';
+  if (!shouldProbeProvider(provider)) return entries[provider].status;
+
+  const promise = (async () => {
+    setProviderStatus(provider, 'checking');
+
+    if (!definition.availabilityProbeUrls.length) {
+      setProviderStatus(provider, 'available');
+      return 'available' as const;
+    }
+    if (typeof window === 'undefined' || typeof Image === 'undefined') {
+      setProviderStatus(provider, 'unknown');
+      return 'unknown' as const;
+    }
+
+    const results = await Promise.all(definition.availabilityProbeUrls.map((url) => probeImageUrl(url)));
+    const status: ProviderAvailabilityStatus = results.every(Boolean) ? 'available' : 'unavailable';
+    setProviderStatus(provider, status);
+    return status;
+  })();
+
+  inFlight.set(provider, promise);
+  try {
+    return await promise;
+  } finally {
+    inFlight.delete(provider);
+  }
+}
+
+export async function ensureProviderAvailability(runtime: MediaHostingRuntime): Promise<ProviderAvailabilitySnapshot> {
+  await Promise.all(getRuntimeSupportedProviders(runtime).map((provider) => probeProviderAvailability(provider)));
+  return getProviderAvailabilitySnapshot();
+}
+
+export function resetProviderAvailabilityForTests() {
+  entries = Object.fromEntries(MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, { status: 'unknown', checkedAt: 0 }])) as Record<
+    ProviderId,
+    ProviderAvailabilityEntry
+  >;
+  inFlight.clear();
+  emit();
+}

src/lib/media-hosting/provider-order.ts

@@ -1,5 +1,6 @@
 import type { MediaHostingRuntime, ProviderId, UploadMode } from './types';
 import { MEDIA_HOSTING_PROVIDERS } from './providers';
+import type { ProviderAvailabilitySnapshot } from './provider-availability';
 
 /** Returns [preferredProvider] for preferred mode */
 export function getPreferredOrder(preferredProvider: ProviderId): ProviderId[] {
@@ -22,9 +23,14 @@ function getSupportedProviders(runtime: MediaHostingRuntime): ProviderId[] {
 }
 
 /** Get ordered provider list for an upload attempt */
-export function getProviderOrder(options: { mode: UploadMode; preferredProvider: ProviderId; runtime: MediaHostingRuntime }): ProviderId[] {
-  const { mode, preferredProvider, runtime } = options;
-  const supported = getSupportedProviders(runtime);
+export function getProviderOrder(options: {
+  mode: UploadMode;
+  preferredProvider: ProviderId;
+  runtime: MediaHostingRuntime;
+  availability?: ProviderAvailabilitySnapshot;
+}): ProviderId[] {
+  const { mode, preferredProvider, runtime, availability } = options;
+  const supported = getSupportedProviders(runtime).filter((provider) => availability?.[provider] !== 'unavailable');
 
   if (mode === 'none') return [];
   if (mode === 'preferred') {

src/lib/media-hosting/show-upload-controls.ts

@@ -1,13 +1,19 @@
 import { Capacitor } from '@capacitor/core';
-import type { UploadMode } from './types';
+import type { MediaHostingRuntime, UploadMode } from './types';
 
-function isElectronRuntime(): boolean {
+export function isElectronRuntime(): boolean {
   return window.electronApi?.isElectron === true || window.isElectron === true;
 }
 
+export function getMediaHostingRuntime(): MediaHostingRuntime {
+  if (Capacitor.getPlatform() === 'android') return 'android';
+  if (isElectronRuntime()) return 'electron';
+  return 'web';
+}
+
 /** Web runtime = web browser, not Electron */
 export function isWebRuntime(): boolean {
-  return Capacitor.getPlatform() === 'web' && !isElectronRuntime();
+  return getMediaHostingRuntime() === 'web';
 }
 
 /**