@chromahq/core 1.0.46 → 1.0.48

package/dist/{boot-PA1aK9w-.js → boot-CgF0JVQl.js}

@@ -2,6 +2,311 @@
 
 var container$1 = require('@inversifyjs/container');
 
+const NONCE_STORE_STORAGE_KEY = "__CHROMA_NONCE_STORE__";
+class NonceService {
+  constructor() {
+    /** In-memory nonce store */
+    this.nonceStore = /* @__PURE__ */ new Map();
+    /** Default TTL for completed/failed entries (24 hours) */
+    this.DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+    /** TTL for pending entries (5 minutes) */
+    this.PENDING_TTL_MS = 5 * 60 * 1e3;
+    /** Maximum entries to prevent unbounded growth */
+    this.MAX_ENTRIES = 500;
+    /** Interval handle for periodic cleanup */
+    this.cleanupInterval = null;
+    /** Whether store has been loaded from persistence */
+    this.loaded = false;
+    /** Promise for initial load operation */
+    this.loadPromise = null;
+    /** Debounce timer for persistence */
+    this.persistTimer = null;
+    /** In-flight persistence promise */
+    this.persistInFlight = null;
+    this.startCleanup();
+    void this.ensureLoaded();
+  }
+  /**
+   * Ensure nonce store has been loaded from storage.
+   * Safe to call multiple times.
+   */
+  async ensureLoaded() {
+    if (this.loaded) return;
+    if (this.loadPromise) return this.loadPromise;
+    this.loadPromise = (async () => {
+      this.loaded = true;
+      if (typeof chrome === "undefined" || !chrome.storage?.local?.get) {
+        return;
+      }
+      try {
+        const result = await chrome.storage.local.get(NONCE_STORE_STORAGE_KEY);
+        const raw = result?.[NONCE_STORE_STORAGE_KEY];
+        if (!raw || typeof raw !== "object") {
+          return;
+        }
+        const now = Date.now();
+        const entries = raw;
+        Object.entries(entries).forEach(([nonce, entry]) => {
+          if (!entry || typeof entry !== "object") return;
+          if (typeof entry.expiresAt !== "number" || now > entry.expiresAt) return;
+          if (entry.status !== "pending" && entry.status !== "completed" && entry.status !== "failed")
+            return;
+          this.nonceStore.set(nonce, entry);
+        });
+      } catch {
+      }
+    })();
+    return this.loadPromise;
+  }
+  /**
+   * Check if a nonce has already been processed
+   * @returns NonceCheckResult with cached data if exists
+   */
+  async checkNonce(nonce) {
+    await this.ensureLoaded();
+    const entry = this.nonceStore.get(nonce);
+    if (!entry) {
+      return { exists: false };
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.nonceStore.delete(nonce);
+      return { exists: false };
+    }
+    return {
+      exists: true,
+      status: entry.status,
+      result: entry.result,
+      error: entry.error
+    };
+  }
+  /**
+   * Mark a nonce as pending (operation started but not completed)
+   * This prevents duplicate submissions while operation is in progress
+   */
+  async markPending(nonce, timestamp) {
+    await this.ensureLoaded();
+    this.nonceStore.set(nonce, {
+      status: "pending",
+      timestamp,
+      expiresAt: Date.now() + this.PENDING_TTL_MS
+    });
+    this.enforceLimits();
+    this.schedulePersist();
+  }
+  /**
+   * Store the result of a completed operation
+   */
+  async storeResult(nonce, result, ttlMs) {
+    await this.ensureLoaded();
+    const existing = this.nonceStore.get(nonce);
+    const timestamp = existing?.timestamp || Date.now();
+    this.nonceStore.set(nonce, {
+      result,
+      status: "completed",
+      timestamp,
+      expiresAt: Date.now() + (ttlMs || this.DEFAULT_TTL_MS)
+    });
+    this.enforceLimits();
+    this.schedulePersist();
+  }
+  /**
+   * Store an error result (operation failed)
+   * We store failures too so retries get the same error
+   */
+  async storeError(nonce, error, ttlMs) {
+    await this.ensureLoaded();
+    const existing = this.nonceStore.get(nonce);
+    const timestamp = existing?.timestamp || Date.now();
+    this.nonceStore.set(nonce, {
+      error,
+      status: "failed",
+      timestamp,
+      expiresAt: Date.now() + (ttlMs || this.DEFAULT_TTL_MS)
+    });
+    this.enforceLimits();
+    this.schedulePersist();
+  }
+  /**
+   * Remove a nonce (e.g., if operation was cancelled before starting)
+   */
+  async removeNonce(nonce) {
+    await this.ensureLoaded();
+    this.nonceStore.delete(nonce);
+    this.schedulePersist();
+  }
+  /**
+   * Check if a payload is a critical operation
+   */
+  isCriticalPayload(payload) {
+    if (!payload || typeof payload !== "object") {
+      return false;
+    }
+    const p = payload;
+    return p.__critical__ === true && typeof p.__nonce__ === "string";
+  }
+  /**
+   * Get statistics about the nonce store (for debugging)
+   */
+  getStats() {
+    let pending = 0;
+    let completed = 0;
+    let failed = 0;
+    this.nonceStore.forEach((entry) => {
+      switch (entry.status) {
+        case "pending":
+          pending++;
+          break;
+        case "completed":
+          completed++;
+          break;
+        case "failed":
+          failed++;
+          break;
+      }
+    });
+    return { total: this.nonceStore.size, pending, completed, failed };
+  }
+  /**
+   * Start periodic cleanup of expired nonces
+   */
+  startCleanup() {
+    if (this.cleanupInterval) return;
+    this.cleanupInterval = setInterval(
+      () => {
+        this.cleanup();
+      },
+      5 * 60 * 1e3
+    );
+  }
+  /**
+   * Remove expired nonces
+   */
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    this.nonceStore.forEach((entry, nonce) => {
+      if (now > entry.expiresAt) {
+        this.nonceStore.delete(nonce);
+        removed++;
+      }
+    });
+    if (removed > 0) {
+      console.log(`[NonceService] Cleaned up ${removed} expired nonces`);
+    }
+  }
+  /**
+   * Destroy the service (stop cleanup interval)
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    this.nonceStore.clear();
+  }
+  enforceLimits() {
+    if (this.nonceStore.size <= this.MAX_ENTRIES) return;
+    const sorted = Array.from(this.nonceStore.entries()).sort(
+      (a, b) => (a[1].timestamp ?? 0) - (b[1].timestamp ?? 0)
+    );
+    const toRemove = this.nonceStore.size - this.MAX_ENTRIES;
+    for (let index = 0; index < toRemove; index++) {
+      this.nonceStore.delete(sorted[index][0]);
+    }
+  }
+  schedulePersist() {
+    if (typeof chrome === "undefined" || !chrome.storage?.local?.set) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      void this.persist();
+    }, 250);
+  }
+  async persist() {
+    if (this.persistInFlight) {
+      return this.persistInFlight;
+    }
+    if (typeof chrome === "undefined" || !chrome.storage?.local?.set) {
+      return;
+    }
+    this.persistInFlight = (async () => {
+      try {
+        const now = Date.now();
+        const obj = {};
+        this.nonceStore.forEach((entry, nonce) => {
+          if (now <= entry.expiresAt) {
+            obj[nonce] = entry;
+          }
+        });
+        await chrome.storage.local.set({ [NONCE_STORE_STORAGE_KEY]: obj });
+      } catch {
+      } finally {
+        this.persistInFlight = null;
+      }
+    })();
+    return this.persistInFlight;
+  }
+}
+let nonceServiceInstance = null;
+function getNonceService() {
+  if (!nonceServiceInstance) {
+    nonceServiceInstance = new NonceService();
+  }
+  return nonceServiceInstance;
+}
+
+const DEFAULT_PORT_NAME$1 = "chroma-bridge";
+const earlyPorts = [];
+let listenerSetup = false;
+let portsClaimed = false;
+let onPortConnectCallback = null;
+function setupEarlyListener(portName = DEFAULT_PORT_NAME$1) {
+  if (listenerSetup) {
+    return;
+  }
+  listenerSetup = true;
+  chrome.runtime.onConnect.addListener((port) => {
+    if (port.name !== portName) {
+      return;
+    }
+    if (portsClaimed && onPortConnectCallback) {
+      onPortConnectCallback(port);
+    } else {
+      console.log(`[EarlyListener] Captured early port connection: ${port.name}`);
+      earlyPorts.push(port);
+    }
+  });
+  console.log(`[EarlyListener] Early connection listener registered for port: ${portName}`);
+}
+function claimEarlyPorts(onConnect) {
+  if (portsClaimed) {
+    console.warn("[EarlyListener] Ports already claimed, returning empty array");
+    return [];
+  }
+  portsClaimed = true;
+  onPortConnectCallback = onConnect;
+  const captured = [...earlyPorts];
+  earlyPorts.length = 0;
+  if (captured.length > 0) {
+    console.log(`[EarlyListener] Claimed ${captured.length} early port(s)`);
+  }
+  return captured;
+}
+function isEarlyListenerSetup() {
+  return listenerSetup;
+}
+function arePortsClaimed() {
+  return portsClaimed;
+}
+
 const container = new container$1.Container({
   defaultScope: "Singleton"
 });
@@ -96,10 +401,13 @@ const _BridgeRuntimeManager = class _BridgeRuntimeManager {
     this.isInitialized = true;
   }
   /**
-   * Setup Chrome runtime port listener
+   * Setup Chrome runtime port listener.
+   *
+   * If early listener was set up (via setupEarlyListener), this will claim
+   * any ports captured during bootstrap and wire them up.
    */
   setupPortListener() {
-    chrome.runtime.onConnect.addListener((port) => {
+    const handlePort = (port) => {
       try {
         if (!this.isValidPort(port)) {
           return;
@@ -117,7 +425,18 @@ const _BridgeRuntimeManager = class _BridgeRuntimeManager {
           chrome.runtime.lastError;
         }
       }
-    });
+    };
+    if (isEarlyListenerSetup()) {
+      const earlyPorts = claimEarlyPorts(handlePort);
+      if (earlyPorts.length > 0) {
+        this.logger.info(
+          `\u{1F4E1} Processing ${earlyPorts.length} early port(s) captured during bootstrap`
+        );
+        earlyPorts.forEach(handlePort);
+      }
+    } else {
+      chrome.runtime.onConnect.addListener(handlePort);
+    }
   }
   setupDirectMessageListener() {
     if (!chrome?.runtime?.onMessage?.addListener) {
@@ -218,7 +537,7 @@ const _BridgeRuntimeManager = class _BridgeRuntimeManager {
           id: request.id,
           hasPayload: !!request.payload
         });
-        const response = await this.processMessage(context);
+        const response = await this.processMessage(context, port);
         this.sendResponse(port, response);
       } catch (error) {
         if (!("type" in message)) {
@@ -261,7 +580,7 @@ const _BridgeRuntimeManager = class _BridgeRuntimeManager {
   /**
    * Process message through middleware pipeline and handler
    */
-  async processMessage(context) {
+  async processMessage(context, senderPort) {
     const { request } = context;
     if (request.key === "__ping__") {
       return {
@@ -278,23 +597,83 @@ const _BridgeRuntimeManager = class _BridgeRuntimeManager {
       };
     }
     this.logger.debug(`Processing message: ${request.key} (id: ${request.id})`);
+    const nonceService = getNonceService();
+    const isCritical = nonceService.isCriticalPayload(request.payload);
+    let nonce;
+    let actualPayload = request.payload;
+    if (isCritical) {
+      const criticalPayload = request.payload;
+      nonce = criticalPayload.__nonce__;
+      actualPayload = criticalPayload.data;
+      this.logger.debug(`Critical operation detected: ${request.key} (nonce: ${nonce})`);
+      const nonceCheck = await nonceService.checkNonce(nonce);
+      if (nonceCheck.exists) {
+        this.logger.debug(`Duplicate nonce detected: ${nonce} (status: ${nonceCheck.status})`);
+        if (nonceCheck.status === "completed") {
+          return {
+            id: request.id,
+            data: nonceCheck.result,
+            timestamp: Date.now()
+          };
+        } else if (nonceCheck.status === "failed") {
+          return {
+            id: request.id,
+            error: nonceCheck.error || "Operation previously failed",
+            timestamp: Date.now()
+          };
+        } else if (nonceCheck.status === "pending") {
+          return {
+            id: request.id,
+            error: "Operation already in progress",
+            timestamp: Date.now()
+          };
+        }
+      }
+      await nonceService.markPending(nonce, criticalPayload.__timestamp__);
+      if (senderPort) {
+        try {
+          senderPort.postMessage({
+            type: "broadcast",
+            key: `__ack__:${nonce}`,
+            payload: { received: true, timestamp: Date.now() }
+          });
+          this.logger.debug(`Sent acknowledgment for nonce: ${nonce}`);
+        } catch (e) {
+          this.logger.warn(`Failed to send acknowledgment for nonce: ${nonce} - ${e}`);
+        }
+      }
+    }
     const handler = this.resolveHandler(request.key);
     const middlewares = MiddlewareRegistry.pipeline(request.key);
     this.logger.debug(
       `Running pipeline for: ${request.key} with ${middlewares.length} middlewares`
     );
-    const data = await this.runPipeline(middlewares, context, async () => {
-      this.logger.debug(`Executing handler for: ${request.key}`);
-      const result = await handler.handle(request.payload);
-      this.logger.debug(`Handler completed for: ${request.key}`, { resultType: typeof result });
-      return result;
-    });
-    this.logger.debug(`Message processed: ${request.key} (id: ${request.id})`);
-    return {
-      id: request.id,
-      data,
-      timestamp: Date.now()
-    };
+    const handlerContext = isCritical ? { ...context, request: { ...request, payload: actualPayload } } : context;
+    try {
+      const data = await this.runPipeline(middlewares, handlerContext, async () => {
+        this.logger.debug(`Executing handler for: ${request.key}`);
+        const result = await handler.handle(actualPayload);
+        this.logger.debug(`Handler completed for: ${request.key}`, { resultType: typeof result });
+        return result;
+      });
+      if (isCritical && nonce) {
+        await nonceService.storeResult(nonce, data);
+        this.logger.debug(`Stored result for nonce: ${nonce}`);
+      }
+      this.logger.debug(`Message processed: ${request.key} (id: ${request.id})`);
+      return {
+        id: request.id,
+        data,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      if (isCritical && nonce) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await nonceService.storeError(nonce, errorMessage);
+        this.logger.debug(`Stored error for nonce: ${nonce}`);
+      }
+      throw error;
+    }
   }
   /**
    * Resolve message handler from dependency injection container
@@ -2072,7 +2451,13 @@ class BootstrapBuilder {
 }
 
 exports.JobState = JobState;
+exports.NonceService = NonceService;
+exports.arePortsClaimed = arePortsClaimed;
 exports.bootstrap = bootstrap;
+exports.claimEarlyPorts = claimEarlyPorts;
 exports.container = container;
 exports.create = create;
-//# sourceMappingURL=boot-PA1aK9w-.js.map
+exports.getNonceService = getNonceService;
+exports.isEarlyListenerSetup = isEarlyListenerSetup;
+exports.setupEarlyListener = setupEarlyListener;
+//# sourceMappingURL=boot-CgF0JVQl.js.map