@xiboplayer/cache 0.5.8 → 0.5.9

package/src/cache.js

@@ -1,17 +1,15 @@
 /**
  * CacheManager - Dependant tracking and cache lifecycle
  *
- * After the cache unification, all downloads and file retrieval go through
- * the Service Worker (via CacheProxy). This class retains:
+ * After the storage unification, all downloads and file retrieval go through
+ * the proxy's ContentStore (via StoreClient/DownloadClient). This class retains:
  * - Dependant tracking (which layouts reference which media)
  * - Cache key generation
- * - Full cache clearing
  */
 
 import { createLogger } from '@xiboplayer/utils';
 
 const log = createLogger('Cache');
-const CACHE_NAME = 'xibo-media-v1';
 
 // Dynamic base path for multi-variant deployment (pwa, pwa-xmds, pwa-xlr)
 const BASE = (typeof window !== 'undefined')
@@ -80,10 +78,9 @@ export class CacheManager {
   }
 
   /**
-   * Clear all cached files
+   * Clear all cached files via proxy
    */
   async clearAll() {
-    await caches.delete(CACHE_NAME);
     this.dependants.clear();
   }
 }

package/src/cache.test.js

@@ -2,7 +2,7 @@
  * Cache Manager Tests
  *
  * Tests for the slimmed-down CacheManager: dependant tracking, getCacheKey,
- * and clearAll. Download/IndexedDB methods have been removed (handled by SW).
+ * and clearAll. Storage is handled by ContentStore via proxy REST endpoints.
  */
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
@@ -10,36 +10,8 @@ import { CacheManager } from './cache.js';
 
 describe('CacheManager', () => {
   let manager;
-  let mockCache;
 
   beforeEach(async () => {
-    // Mock Cache API
-    mockCache = {
-      _storage: new Map(),
-      async match(key) {
-        const keyStr = typeof key === 'string' ? key : key.toString();
-        const entry = this._storage.get(keyStr);
-        if (!entry) return undefined;
-        return new Response(entry.body, { headers: entry.headers });
-      },
-      async put(key, response) {
-        const keyStr = typeof key === 'string' ? key : key.toString();
-        const bodyText = await response.text();
-        const headers = {};
-        response.headers.forEach((value, name) => { headers[name] = value; });
-        this._storage.set(keyStr, { body: bodyText, headers });
-      },
-      async delete(key) {
-        const keyStr = typeof key === 'string' ? key : key.toString();
-        return this._storage.delete(keyStr);
-      }
-    };
-
-    global.caches = {
-      async open() { return mockCache; },
-      async delete() { mockCache._storage.clear(); }
-    };
-
     manager = new CacheManager();
   });
 
@@ -155,7 +127,7 @@ describe('CacheManager', () => {
   });
 
   describe('clearAll()', () => {
-    it('should clear caches and dependants', async () => {
+    it('should clear dependants', async () => {
       manager.addDependant('media1', 'layout1');
       manager.addDependant('media2', 'layout2');
 

package/src/download-client.js

@@ -0,0 +1,222 @@
+/**
+ * DownloadClient — Service Worker postMessage interface for download orchestration
+ *
+ * Communicates with the Service Worker via postMessage for:
+ * - Background file downloads (DOWNLOAD_FILES)
+ * - Download prioritization (PRIORITIZE_DOWNLOAD, PRIORITIZE_LAYOUT_FILES)
+ * - Progress reporting (GET_DOWNLOAD_PROGRESS)
+ *
+ * Usage:
+ *   const downloads = new DownloadClient();
+ *   await downloads.init();  // Waits for SW to be ready
+ *   await downloads.download(files);
+ *   downloads.prioritize('media', '123');
+ */
+
+import { createLogger } from '@xiboplayer/utils';
+
+const log = createLogger('DownloadClient');
+
+export class DownloadClient {
+  constructor() {
+    this.controller = null;
+    this.fetchReady = false;
+    this._fetchReadyPromise = null;
+    this._fetchReadyResolve = null;
+  }
+
+  /**
+   * Initialize — waits for Service Worker to be ready and controlling the page.
+   */
+  async init() {
+    if (!('serviceWorker' in navigator)) {
+      throw new Error('Service Worker not supported — PWA requires Service Worker');
+    }
+
+    // Guard against double-initialization (would add duplicate listeners)
+    if (this._swReadyHandler) return;
+
+    // Create promise for fetch readiness (resolved when SW sends SW_READY)
+    this._fetchReadyPromise = new Promise(resolve => {
+      this._fetchReadyResolve = resolve;
+    });
+
+    // Listen for SW_READY message (store handler for cleanup)
+    this._swReadyHandler = (event) => {
+      if (event.data?.type === 'SW_READY') {
+        log.info('Received SW_READY signal — fetch handler is ready');
+        this.fetchReady = true;
+        this._fetchReadyResolve();
+      }
+    };
+    navigator.serviceWorker.addEventListener('message', this._swReadyHandler);
+
+    const registration = await navigator.serviceWorker.getRegistration();
+
+    // FAST PATH: Active SW, no updates pending
+    if (registration && registration.active && !registration.installing && !registration.waiting) {
+      log.info('Active Service Worker found (no updates pending)');
+      this.controller = navigator.serviceWorker.controller || registration.active;
+
+      // If not controlling yet, give it a moment to claim page
+      if (!navigator.serviceWorker.controller) {
+        await new Promise(resolve => setTimeout(resolve, 200));
+      }
+
+      this.controller.postMessage({ type: 'PING' });
+      log.info('DownloadClient initialized, waiting for fetch readiness...');
+      return;
+    }
+
+    // If there's a new SW installing/waiting, wait for it
+    if (registration && (registration.installing || registration.waiting)) {
+      log.info('New Service Worker detected, waiting for it to activate...');
+    }
+
+    // SLOW PATH: No active SW, wait for registration (fresh install)
+    log.info('No active Service Worker, waiting for registration...');
+
+    const swReady = navigator.serviceWorker.ready;
+    const timeout = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Service Worker ready timeout after 10s')), 10000)
+    );
+
+    try {
+      await Promise.race([swReady, timeout]);
+    } catch (error) {
+      log.error('Service Worker wait failed:', error);
+      throw new Error('Service Worker not ready — please reload page');
+    }
+
+    // Wait for SW to claim page
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    this.controller = navigator.serviceWorker.controller;
+    if (!this.controller) {
+      const reg = await navigator.serviceWorker.getRegistration();
+      this.controller = reg?.active;
+    }
+
+    if (this.controller) {
+      this.controller.postMessage({ type: 'PING' });
+    }
+
+    log.info('DownloadClient initialized (slow path)');
+  }
+
+  /**
+   * Wait for fetch readiness before operations that need it.
+   */
+  async _ensureReady() {
+    if (!this.fetchReady && this._fetchReadyPromise) {
+      await this._fetchReadyPromise;
+    }
+  }
+
+  /**
+   * Request file downloads from Service Worker (non-blocking).
+   * @param {Object|Array} payload - { layoutOrder, files, layoutDependants } or flat Array
+   * @returns {Promise<void>}
+   */
+  async download(payload) {
+    if (!this.controller) {
+      throw new Error('Service Worker not available');
+    }
+
+    const data = Array.isArray(payload)
+      ? { files: payload }
+      : payload;
+
+    return new Promise((resolve, reject) => {
+      const messageChannel = new MessageChannel();
+
+      messageChannel.port1.onmessage = (event) => {
+        const { success, error, enqueuedCount, activeCount, queuedCount } = event.data;
+        if (success) {
+          log.info('Download request acknowledged:', enqueuedCount, 'files');
+          log.info('Queue state:', activeCount, 'active,', queuedCount, 'queued');
+          resolve();
+        } else {
+          reject(new Error(error || 'Service Worker download failed'));
+        }
+      };
+
+      this.controller.postMessage(
+        { type: 'DOWNLOAD_FILES', data },
+        [messageChannel.port2]
+      );
+    });
+  }
+
+  /**
+   * Prioritize downloading a specific file (move to front of queue).
+   * @param {string} fileType - 'media' or 'layout'
+   * @param {string} fileId - File ID
+   */
+  async prioritize(fileType, fileId) {
+    if (!this.controller) return;
+
+    return new Promise((resolve) => {
+      const messageChannel = new MessageChannel();
+      messageChannel.port1.onmessage = (event) => resolve(event.data);
+      this.controller.postMessage(
+        { type: 'PRIORITIZE_DOWNLOAD', data: { fileType, fileId } },
+        [messageChannel.port2]
+      );
+    });
+  }
+
+  /**
+   * Prioritize layout files — reorder queue and hold other downloads until done.
+   * @param {string[]} mediaIds - Media IDs needed by the current layout
+   */
+  async prioritizeLayout(mediaIds) {
+    if (!this.controller) return;
+    this.controller.postMessage({ type: 'PRIORITIZE_LAYOUT_FILES', data: { mediaIds } });
+  }
+
+  /**
+   * Get download progress from Service Worker.
+   * @returns {Promise<Object>} Progress info for all active downloads
+   */
+  async getProgress() {
+    if (!this.controller) return {};
+
+    return new Promise((resolve) => {
+      const channel = new MessageChannel();
+      let settled = false;
+
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          channel.port1.onmessage = null;
+          resolve({});
+        }
+      }, 1000);
+
+      channel.port1.onmessage = (event) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          const { success, progress } = event.data;
+          resolve(success ? progress : {});
+        }
+      };
+
+      this.controller.postMessage(
+        { type: 'GET_DOWNLOAD_PROGRESS' },
+        [channel.port2]
+      );
+    });
+  }
+
+  /**
+   * Remove event listeners added during init().
+   */
+  cleanup() {
+    if (this._swReadyHandler && 'serviceWorker' in navigator) {
+      navigator.serviceWorker.removeEventListener('message', this._swReadyHandler);
+      this._swReadyHandler = null;
+    }
+  }
+}

package/src/download-manager.js

@@ -40,6 +40,7 @@ const RETRY_DELAY_MS = 500; // Fast: 500ms, 1s, 1.5s → total ~3s
 const GETDATA_MAX_RETRIES = 4;
 const GETDATA_RETRY_DELAYS = [15_000, 30_000, 60_000, 120_000]; // 15s, 30s, 60s, 120s
 const GETDATA_REENQUEUE_DELAY_MS = 60_000; // Re-add to queue after 60s if all retries fail
+const GETDATA_MAX_REENQUEUES = 5; // Max times a getData can be re-enqueued before permanent failure
 const URGENT_CONCURRENCY = 2; // Slots when urgent chunk is active (bandwidth focus)
 const FETCH_TIMEOUT_MS = 600_000; // 10 minutes — 100MB chunk at ~2 Mbps
 const HEAD_TIMEOUT_MS = 15_000; // 15 seconds for HEAD requests
@@ -108,7 +109,7 @@ export function isUrlExpired(url, graceSeconds = 30) {
  * the proxy server (Chromium kiosk or Electron).
  * Detection: SW/window on localhost (any port) = proxy mode.
  */
-export function rewriteUrlForProxy(url) {
+export function toProxyUrl(url) {
   if (!url.startsWith('http')) return url;
   const loc = typeof self !== 'undefined' ? self.location : undefined;
   if (!loc || loc.hostname !== 'localhost') return url;
@@ -142,7 +143,24 @@ export class DownloadTask {
     if (isUrlExpired(url)) {
       throw new Error(`URL expired for ${this.fileInfo.type}/${this.fileInfo.id} — waiting for fresh URL from next collection cycle`);
     }
-    return rewriteUrlForProxy(url);
+    let proxyUrl = toProxyUrl(url);
+
+    // Append store key params so the proxy can save to ContentStore
+    if (proxyUrl.startsWith('/file-proxy')) {
+      const storeKey = `${this.fileInfo.type || 'media'}/${this.fileInfo.id}`;
+      proxyUrl += `&storeKey=${encodeURIComponent(storeKey)}`;
+      if (this.chunkIndex != null) {
+        proxyUrl += `&chunkIndex=${this.chunkIndex}`;
+        if (this._parentFile) {
+          proxyUrl += `&numChunks=${this._parentFile.totalChunks}`;
+          proxyUrl += `&chunkSize=${this._parentFile.options.chunkSize || 104857600}`;
+        }
+      }
+      if (this.fileInfo.md5) {
+        proxyUrl += `&md5=${encodeURIComponent(this.fileInfo.md5)}`;
+      }
+    }
+    return proxyUrl;
   }
 
   async start() {
@@ -233,7 +251,17 @@ export class FileDownload {
     if (isUrlExpired(url)) {
       throw new Error(`URL expired for ${this.fileInfo.type}/${this.fileInfo.id} — waiting for fresh URL from next collection cycle`);
     }
-    return rewriteUrlForProxy(url);
+    let proxyUrl = toProxyUrl(url);
+
+    // Append store key for ContentStore (same as DownloadTask)
+    if (proxyUrl.startsWith('/file-proxy')) {
+      const storeKey = `${this.fileInfo.type || 'media'}/${this.fileInfo.id}`;
+      proxyUrl += `&storeKey=${encodeURIComponent(storeKey)}`;
+      if (this.fileInfo.md5) {
+        proxyUrl += `&md5=${encodeURIComponent(this.fileInfo.md5)}`;
+      }
+    }
+    return proxyUrl;
   }
 
   wait() {
@@ -578,6 +606,9 @@ export class DownloadQueue {
 
     // When paused, processQueue() is a no-op (used during barrier setup)
     this.paused = false;
+
+    // Track getData re-enqueue timers so clear() can cancel them
+    this._reenqueueTimers = new Set();
   }
 
   static stableKey(fileInfo) {
@@ -875,14 +906,23 @@ export class DownloadQueue {
         // getData (widget data): defer re-enqueue instead of permanent failure.
         // CMS "cache not ready" resolves when the XTR task runs (30-120s).
         if (task.isGetData) {
-          log.warn(`[DownloadQueue] getData ${key} failed all retries, scheduling re-enqueue in ${GETDATA_REENQUEUE_DELAY_MS / 1000}s`);
-          setTimeout(() => {
+          task._reenqueueCount = (task._reenqueueCount || 0) + 1;
+          if (task._reenqueueCount > GETDATA_MAX_REENQUEUES) {
+            log.error(`[DownloadQueue] getData ${key} exceeded ${GETDATA_MAX_REENQUEUES} re-enqueues, failing permanently`);
+            this.processQueue();
+            task._parentFile.onTaskFailed(task, err);
+            return;
+          }
+          log.warn(`[DownloadQueue] getData ${key} failed all retries (attempt ${task._reenqueueCount}/${GETDATA_MAX_REENQUEUES}), scheduling re-enqueue in ${GETDATA_REENQUEUE_DELAY_MS / 1000}s`);
+          const timerId = setTimeout(() => {
+            this._reenqueueTimers.delete(timerId);
             task.state = 'pending';
             task._parentFile.state = 'downloading';
             this.queue.push(task);
             log.info(`[DownloadQueue] getData ${key} re-enqueued for retry`);
             this.processQueue();
           }, GETDATA_REENQUEUE_DELAY_MS);
+          this._reenqueueTimers.add(timerId);
           this.processQueue();
           return;
         }
@@ -941,6 +981,9 @@ export class DownloadQueue {
     this.running = 0;
     this._prepareQueue = [];
     this._preparingCount = 0;
+    // Cancel any pending getData re-enqueue timers
+    for (const id of this._reenqueueTimers) clearTimeout(id);
+    this._reenqueueTimers.clear();
   }
 }
 

package/src/index.js

@@ -2,7 +2,8 @@
 import pkg from '../package.json' with { type: 'json' };
 export const VERSION = pkg.version;
 export { CacheManager, cacheManager } from './cache.js';
-export { CacheProxy } from './cache-proxy.js';
-export { DownloadManager, FileDownload, LayoutTaskBuilder, isUrlExpired } from './download-manager.js';
+export { StoreClient } from './store-client.js';
+export { DownloadClient } from './download-client.js';
+export { DownloadManager, FileDownload, LayoutTaskBuilder, isUrlExpired, toProxyUrl } from './download-manager.js';
 export { CacheAnalyzer } from './cache-analyzer.js';
 export { cacheWidgetHtml } from './widget-html.js';

package/src/store-client.js

@@ -0,0 +1,114 @@
+/**
+ * StoreClient — Pure REST client for ContentStore
+ *
+ * Communicates with the proxy's /store/* endpoints via fetch().
+ * No Service Worker dependency — works immediately after construction.
+ *
+ * Usage:
+ *   const store = new StoreClient();
+ *   const exists = await store.has('media', '123');
+ *   const blob = await store.get('media', '123');
+ *   await store.put('widget', 'layout/1/region/2/media/3', htmlBlob, 'text/html');
+ *   await store.remove([{ type: 'media', id: '456' }]);
+ *   const files = await store.list();
+ */
+
+import { createLogger } from '@xiboplayer/utils';
+
+const log = createLogger('StoreClient');
+
+export class StoreClient {
+  /**
+   * Check if a file exists in the store.
+   * @param {string} type - 'media', 'layout', 'widget', 'static'
+   * @param {string} id - File ID or path
+   * @returns {Promise<boolean>}
+   */
+  async has(type, id) {
+    try {
+      const response = await fetch(`/store/${type}/${id}`, { method: 'HEAD' });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get a file from the store as a Blob.
+   * @param {string} type - 'media', 'layout', 'widget', 'static'
+   * @param {string} id - File ID or path
+   * @returns {Promise<Blob|null>}
+   */
+  async get(type, id) {
+    try {
+      const response = await fetch(`/store/${type}/${id}`);
+      if (!response.ok) {
+        response.body?.cancel();
+        if (response.status === 404) return null;
+        throw new Error(`Failed to get file: ${response.status}`);
+      }
+      return await response.blob();
+    } catch (error) {
+      log.error('get error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Store a file in the ContentStore.
+   * @param {string} type - 'media', 'layout', 'widget', 'static'
+   * @param {string} id - File ID or path
+   * @param {Blob|ArrayBuffer|string} body - Content to store
+   * @param {string} [contentType='application/octet-stream'] - MIME type
+   * @returns {Promise<boolean>} true if stored successfully
+   */
+  async put(type, id, body, contentType = 'application/octet-stream') {
+    try {
+      const response = await fetch(`/store/${type}/${id}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': contentType },
+        body,
+      });
+      response.body?.cancel();
+      return response.ok;
+    } catch (error) {
+      log.error('put error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Delete files from the store.
+   * @param {Array<{type: string, id: string}>} files - Files to delete
+   * @returns {Promise<{deleted: number, total: number}>}
+   */
+  async remove(files) {
+    try {
+      const response = await fetch('/store/delete', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ files }),
+      });
+      const result = await response.json();
+      return { deleted: result.deleted || 0, total: result.total || files.length };
+    } catch (error) {
+      log.error('remove error:', error.message);
+      return { deleted: 0, total: files.length };
+    }
+  }
+
+  /**
+   * List all files in the store.
+   * @returns {Promise<Array<{id: string, type: string, size: number}>>}
+   */
+  async list() {
+    try {
+      const response = await fetch('/store/list');
+      const data = await response.json();
+      return data.files || [];
+    } catch (error) {
+      log.error('list error:', error.message);
+      return [];
+    }
+  }
+}