@mcp-fe/mcp-worker 0.0.9 → 0.0.12

package/index.js

@@ -1,4 +1,5 @@
-class W {
+// libs/mcp-worker/src/lib/worker-client.ts
+var WorkerClient = class {
   serviceWorkerRegistration = null;
   sharedWorker = null;
   sharedWorkerPort = null;
@@ -10,246 +11,369 @@ class W {
   // Mutex/promise to prevent concurrent init runs
   initPromise = null;
   // Initialize and choose worker implementation (prefer SharedWorker)
-  async init(e) {
-    return this.initPromise ? this.initPromise.then(async () => {
-      e && this.workerType !== "service" && await this.init(e);
-    }) : (this.initPromise = (async () => {
+  async init(registration) {
+    if (this.initPromise) {
+      return this.initPromise.then(async () => {
+        if (registration && this.workerType !== "service") {
+          await this.init(registration);
+        }
+      });
+    }
+    this.initPromise = (async () => {
       try {
-        if (e) {
-          this.serviceWorkerRegistration = e, this.workerType = "service", console.log("[WorkerClient] Using ServiceWorker (explicit registration)"), this.pendingAuthToken && (this.sendAuthTokenToServiceWorker(this.pendingAuthToken), this.pendingAuthToken = null);
+        if (registration) {
+          this.serviceWorkerRegistration = registration;
+          this.workerType = "service";
+          console.log("[WorkerClient] Using ServiceWorker (explicit registration)");
+          if (this.pendingAuthToken) {
+            this.sendAuthTokenToServiceWorker(this.pendingAuthToken);
+            this.pendingAuthToken = null;
+          }
           return;
         }
-        if (typeof SharedWorker < "u")
+        if (typeof SharedWorker !== "undefined") {
           try {
-            if (this.sharedWorker = new SharedWorker("/shared-worker.js", { type: "module" }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), this.pendingAuthToken && this.sharedWorkerPort)
+            this.sharedWorker = new SharedWorker("/mcp-shared-worker.js", { type: "module" });
+            this.sharedWorkerPort = this.sharedWorker.port;
+            this.sharedWorkerPort.start();
+            if (this.pendingAuthToken && this.sharedWorkerPort) {
               try {
                 this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken });
-              } catch (o) {
-                console.warn("[WorkerClient] Immediate postMessage to SharedWorker failed (will retry after init):", o);
+              } catch (err) {
+                console.warn("[WorkerClient] Immediate postMessage to SharedWorker failed (will retry after init):", err);
               }
-            this.sharedWorker.onerror = (o) => {
-              console.error("[WorkerClient] SharedWorker error:", o.message || o.error || o), this.workerType !== "shared" && this.initServiceWorkerFallback().catch((s) => {
-                console.error("[WorkerClient] Failed to initialize ServiceWorker fallback:", s);
-              });
-            }, await new Promise((o, s) => {
-              let n = !1;
-              const c = setTimeout(() => {
-                if (!n) {
-                  const r = this.sharedWorkerPort;
-                  r && (r.onmessage = null), s(new Error("SharedWorker initialization timeout"));
+            }
+            this.sharedWorker.onerror = (event) => {
+              console.error("[WorkerClient] SharedWorker error:", event.message || event.error || event);
+              if (this.workerType !== "shared") {
+                this.initServiceWorkerFallback().catch((err) => {
+                  console.error("[WorkerClient] Failed to initialize ServiceWorker fallback:", err);
+                });
+              }
+            };
+            await new Promise((resolve, reject) => {
+              let resolved = false;
+              const timeout = setTimeout(() => {
+                if (!resolved) {
+                  const p2 = this.sharedWorkerPort;
+                  if (p2)
+                    p2.onmessage = null;
+                  reject(new Error("SharedWorker initialization timeout"));
                 }
-              }, 2e3), a = this.sharedWorkerPort;
-              if (!a)
-                return clearTimeout(c), s(new Error("SharedWorker port not available"));
-              a.onmessage = (r) => {
+              }, 2e3);
+              const p = this.sharedWorkerPort;
+              if (!p) {
+                clearTimeout(timeout);
+                return reject(new Error("SharedWorker port not available"));
+              }
+              p.onmessage = (ev) => {
                 try {
-                  const i = r.data;
-                  i && i.type === "CONNECTION_STATUS" && (clearTimeout(c), n = !0, this.workerType = "shared", a.onmessage = null, o());
+                  const data = ev.data;
+                  if (data && data.type === "CONNECTION_STATUS") {
+                    clearTimeout(timeout);
+                    resolved = true;
+                    this.workerType = "shared";
+                    p.onmessage = null;
+                    resolve();
+                  }
                 } catch {
                 }
               };
             });
-            const t = this.sharedWorkerPort;
-            if (this.pendingAuthToken && t)
+            const portAfterInit = this.sharedWorkerPort;
+            if (this.pendingAuthToken && portAfterInit) {
               try {
-                t.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken }), this.pendingAuthToken = null;
-              } catch (o) {
-                console.error("[WorkerClient] Failed to send pending auth token to SharedWorker:", o);
+                portAfterInit.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken });
+                this.pendingAuthToken = null;
+              } catch (e) {
+                console.error("[WorkerClient] Failed to send pending auth token to SharedWorker:", e);
               }
-            t && (t.onmessage = (o) => {
-              try {
-                const s = o.data;
-                if (s && s.type === "CONNECTION_STATUS") {
-                  const n = !!s.connected;
-                  this.connectionStatusCallbacks.forEach((c) => {
-                    try {
-                      c(n);
-                    } catch {
-                    }
-                  });
+            }
+            if (portAfterInit) {
+              portAfterInit.onmessage = (ev) => {
+                try {
+                  const data = ev.data;
+                  if (data && data.type === "CONNECTION_STATUS") {
+                    const connected = !!data.connected;
+                    this.connectionStatusCallbacks.forEach((cb) => {
+                      try {
+                        cb(connected);
+                      } catch (e) {
+                      }
+                    });
+                  }
+                } catch {
                 }
-              } catch {
-              }
-            }), console.log("[WorkerClient] Using SharedWorker");
+              };
+            }
+            console.log("[WorkerClient] Using SharedWorker");
             return;
-          } catch (t) {
-            console.warn("[WorkerClient] SharedWorker not available, falling back to ServiceWorker:", t);
+          } catch (error) {
+            console.warn("[WorkerClient] SharedWorker not available, falling back to ServiceWorker:", error);
           }
-        console.log("this should not be called"), await this.initServiceWorkerFallback(), this.pendingAuthToken && this.workerType === "service" && (this.sendAuthTokenToServiceWorker(this.pendingAuthToken), this.pendingAuthToken = null);
+        }
+        console.log("this should not be called");
+        await this.initServiceWorkerFallback();
+        if (this.pendingAuthToken && this.workerType === "service") {
+          this.sendAuthTokenToServiceWorker(this.pendingAuthToken);
+          this.pendingAuthToken = null;
+        }
       } finally {
         this.initPromise = null;
       }
-    })(), this.initPromise);
+    })();
+    return this.initPromise;
   }
   async initServiceWorkerFallback() {
-    if (console.log("initServiceWorkerFallback called"), "serviceWorker" in navigator)
+    console.log("initServiceWorkerFallback called");
+    if ("serviceWorker" in navigator) {
       try {
-        const e = await navigator.serviceWorker.getRegistration();
-        if (e) {
-          this.serviceWorkerRegistration = e, this.workerType = "service", console.log("[WorkerClient] Using existing ServiceWorker registration");
+        const existingRegistration = await navigator.serviceWorker.getRegistration();
+        if (existingRegistration) {
+          this.serviceWorkerRegistration = existingRegistration;
+          this.workerType = "service";
+          console.log("[WorkerClient] Using existing ServiceWorker registration");
           return;
         }
-        const t = await navigator.serviceWorker.register("/sw.js");
-        this.serviceWorkerRegistration = t, this.workerType = "service", console.log("[WorkerClient] Using ServiceWorker (fallback)"), this.serviceWorkerMessageHandler && (navigator.serviceWorker.removeEventListener("message", this.serviceWorkerMessageHandler), this.serviceWorkerMessageHandler = null), this.serviceWorkerMessageHandler = (o) => {
+        const reg = await navigator.serviceWorker.register("/mcp-service-worker.js");
+        this.serviceWorkerRegistration = reg;
+        this.workerType = "service";
+        console.log("[WorkerClient] Using ServiceWorker (fallback)");
+        if (this.serviceWorkerMessageHandler) {
+          navigator.serviceWorker.removeEventListener("message", this.serviceWorkerMessageHandler);
+          this.serviceWorkerMessageHandler = null;
+        }
+        this.serviceWorkerMessageHandler = (ev) => {
           try {
-            const s = o.data;
-            if (s && s.type === "CONNECTION_STATUS") {
-              const n = !!s.connected;
-              this.connectionStatusCallbacks.forEach((c) => {
+            const data = ev.data;
+            if (data && data.type === "CONNECTION_STATUS") {
+              const connected = !!data.connected;
+              this.connectionStatusCallbacks.forEach((cb) => {
                 try {
-                  c(n);
-                } catch {
+                  cb(connected);
+                } catch (e) {
                 }
               });
             }
           } catch {
           }
-        }, navigator.serviceWorker.addEventListener("message", this.serviceWorkerMessageHandler);
-      } catch (e) {
-        throw console.error("[WorkerClient] Failed to register ServiceWorker:", e), e;
+        };
+        navigator.serviceWorker.addEventListener("message", this.serviceWorkerMessageHandler);
+      } catch (error) {
+        console.error("[WorkerClient] Failed to register ServiceWorker:", error);
+        throw error;
       }
-    else
+    } else {
       throw new Error("Neither SharedWorker nor ServiceWorker is supported");
+    }
   }
   // Low-level request that expects a reply via MessageChannel
-  async request(e, t, o = 5e3) {
-    if (this.workerType === "shared" && this.sharedWorkerPort)
-      return new Promise((s, n) => {
-        const c = new MessageChannel(), a = setTimeout(() => {
-          c.port1.onmessage = null, n(new Error("Request timeout"));
-        }, o);
-        c.port1.onmessage = (r) => {
-          clearTimeout(a), r.data && r.data.success ? s(r.data) : r.data && r.data.success === !1 ? n(new Error(r.data.error || "Worker error")) : s(r.data);
+  async request(type, payload, timeoutMs = 5e3) {
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
+      return new Promise((resolve, reject) => {
+        const mc = new MessageChannel();
+        const timer = setTimeout(() => {
+          mc.port1.onmessage = null;
+          reject(new Error("Request timeout"));
+        }, timeoutMs);
+        mc.port1.onmessage = (ev) => {
+          clearTimeout(timer);
+          if (ev.data && ev.data.success) {
+            resolve(ev.data);
+          } else if (ev.data && ev.data.success === false) {
+            reject(new Error(ev.data.error || "Worker error"));
+          } else {
+            resolve(ev.data);
+          }
         };
         try {
-          const r = this.sharedWorkerPort;
-          if (!r)
-            return clearTimeout(a), n(new Error("SharedWorker port not available"));
-          r.postMessage({ type: e, ...t || {} }, [c.port2]);
-        } catch (r) {
-          clearTimeout(a), n(r instanceof Error ? r : new Error(String(r)));
+          const port = this.sharedWorkerPort;
+          if (!port) {
+            clearTimeout(timer);
+            return reject(new Error("SharedWorker port not available"));
+          }
+          port.postMessage({ type, ...payload || {} }, [mc.port2]);
+        } catch (e) {
+          clearTimeout(timer);
+          reject(e instanceof Error ? e : new Error(String(e)));
         }
       });
+    }
     if (this.workerType === "service" && this.serviceWorkerRegistration) {
-      const s = this.serviceWorkerRegistration;
-      if (!s) throw new Error("Service worker registration missing");
-      if (!s.active && (await navigator.serviceWorker.ready, !s.active))
-        throw new Error("Service worker not active");
-      return new Promise((n, c) => {
-        const a = new MessageChannel(), r = setTimeout(() => {
-          a.port1.onmessage = null, c(new Error("Request timeout"));
-        }, o);
-        a.port1.onmessage = (i) => {
-          clearTimeout(r), i.data && i.data.success ? n(i.data) : i.data && i.data.success === !1 ? c(new Error(i.data.error || "Worker error")) : n(i.data);
+      const reg = this.serviceWorkerRegistration;
+      if (!reg)
+        throw new Error("Service worker registration missing");
+      if (!reg.active) {
+        await navigator.serviceWorker.ready;
+        if (!reg.active) {
+          throw new Error("Service worker not active");
+        }
+      }
+      return new Promise((resolve, reject) => {
+        const mc = new MessageChannel();
+        const timer = setTimeout(() => {
+          mc.port1.onmessage = null;
+          reject(new Error("Request timeout"));
+        }, timeoutMs);
+        mc.port1.onmessage = (ev) => {
+          clearTimeout(timer);
+          if (ev.data && ev.data.success) {
+            resolve(ev.data);
+          } else if (ev.data && ev.data.success === false) {
+            reject(new Error(ev.data.error || "Worker error"));
+          } else {
+            resolve(ev.data);
+          }
         };
         try {
-          const i = s.active;
-          if (!i)
-            return clearTimeout(r), c(new Error("Service worker active instance not available"));
-          i.postMessage({ type: e, ...t || {} }, [a.port2]);
-        } catch (i) {
-          clearTimeout(r), c(i instanceof Error ? i : new Error(String(i)));
+          const active = reg.active;
+          if (!active) {
+            clearTimeout(timer);
+            return reject(new Error("Service worker active instance not available"));
+          }
+          active.postMessage({ type, ...payload || {} }, [mc.port2]);
+        } catch (e) {
+          clearTimeout(timer);
+          reject(e instanceof Error ? e : new Error(String(e)));
         }
       });
     }
     throw new Error("No worker registered");
   }
   // Fire-and-forget postMessage (no response expected)
-  async post(e, t) {
+  async post(type, payload) {
     if (this.workerType === "shared" && this.sharedWorkerPort) {
       try {
-        this.sharedWorkerPort.postMessage({ type: e, ...t || {} });
-      } catch (o) {
-        console.error("[WorkerClient] Failed to post to SharedWorker:", o);
+        this.sharedWorkerPort.postMessage({ type, ...payload || {} });
+      } catch (e) {
+        console.error("[WorkerClient] Failed to post to SharedWorker:", e);
       }
       return;
     }
     if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
       try {
-        this.serviceWorkerRegistration.active.postMessage({ type: e, ...t || {} });
-      } catch (o) {
-        console.error("[WorkerClient] Failed to post to ServiceWorker (active):", o);
+        this.serviceWorkerRegistration.active.postMessage({ type, ...payload || {} });
+      } catch (e) {
+        console.error("[WorkerClient] Failed to post to ServiceWorker (active):", e);
       }
       return;
     }
     if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
       try {
-        navigator.serviceWorker.controller.postMessage({ type: e, ...t || {} });
-      } catch (o) {
-        console.error("[WorkerClient] Failed to post to ServiceWorker.controller:", o);
+        navigator.serviceWorker.controller.postMessage({ type, ...payload || {} });
+      } catch (e) {
+        console.error("[WorkerClient] Failed to post to ServiceWorker.controller:", e);
       }
       return;
     }
-    if (e === "SET_AUTH_TOKEN" && t) {
-      const o = t.token;
-      typeof o == "string" && (this.pendingAuthToken = o);
+    if (type === "SET_AUTH_TOKEN" && payload) {
+      const token = payload["token"];
+      if (typeof token === "string")
+        this.pendingAuthToken = token;
     }
   }
-  sendAuthTokenToServiceWorker(e) {
-    if (this.serviceWorkerRegistration?.active)
+  sendAuthTokenToServiceWorker(token) {
+    if (this.serviceWorkerRegistration?.active) {
       try {
-        this.serviceWorkerRegistration.active.postMessage({ type: "SET_AUTH_TOKEN", token: e });
-      } catch (t) {
-        console.error("[WorkerClient] Failed to send auth token to ServiceWorker:", t);
+        this.serviceWorkerRegistration.active.postMessage({ type: "SET_AUTH_TOKEN", token });
+      } catch (e) {
+        console.error("[WorkerClient] Failed to send auth token to ServiceWorker:", e);
       }
-    else if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
+    } else if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
       try {
-        navigator.serviceWorker.controller.postMessage({ type: "SET_AUTH_TOKEN", token: e });
-      } catch (t) {
-        console.error("[WorkerClient] Failed to send auth token to ServiceWorker.controller:", t);
+        navigator.serviceWorker.controller.postMessage({ type: "SET_AUTH_TOKEN", token });
+      } catch (e) {
+        console.error("[WorkerClient] Failed to send auth token to ServiceWorker.controller:", e);
       }
-    else
-      this.pendingAuthToken = e;
+    } else {
+      this.pendingAuthToken = token;
+    }
   }
   // Subscription API for consumers to listen for connection status updates
-  onConnectionStatus(e) {
-    this.connectionStatusCallbacks.add(e);
+  onConnectionStatus(cb) {
+    this.connectionStatusCallbacks.add(cb);
   }
-  offConnectionStatus(e) {
-    this.connectionStatusCallbacks.delete(e);
+  offConnectionStatus(cb) {
+    this.connectionStatusCallbacks.delete(cb);
   }
   async getConnectionStatus() {
     try {
-      const e = await this.request("GET_CONNECTION_STATUS", void 0, 2e3);
-      return e && typeof e == "object" && "connected" in e, !!e.connected;
+      const res = await this.request("GET_CONNECTION_STATUS", void 0, 2e3);
+      if (res && typeof res === "object" && "connected" in res)
+        return !!res.connected;
+      return !!res.connected;
     } catch {
-      return !1;
+      return false;
     }
   }
-  setAuthToken(e) {
-    if (this.pendingAuthToken = e, this.workerType === "shared" && this.sharedWorkerPort)
+  setAuthToken(token) {
+    this.pendingAuthToken = token;
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
       try {
-        this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: e }), this.pendingAuthToken = null;
-      } catch (t) {
-        console.error("[WorkerClient] Failed to set auth token on SharedWorker:", t);
+        this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token });
+        this.pendingAuthToken = null;
+      } catch (e) {
+        console.error("[WorkerClient] Failed to set auth token on SharedWorker:", e);
       }
-    else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(e), this.pendingAuthToken = null);
+    } else if (this.workerType === "service") {
+      this.sendAuthTokenToServiceWorker(token);
+      this.pendingAuthToken = null;
+    } else {
+    }
   }
-}
-const d = "user-activity-db", u = 1, h = "user-events";
-async function g() {
-  return new Promise((l, e) => {
-    const t = indexedDB.open(d, u);
-    t.onerror = () => e(t.error), t.onsuccess = () => l(t.result), t.onupgradeneeded = (o) => {
-      const s = o.target.result;
-      if (!s.objectStoreNames.contains(h)) {
-        const n = s.createObjectStore(h, { keyPath: "id" });
-        n.createIndex("timestamp", "timestamp", { unique: !1 }), n.createIndex("type", "type", { unique: !1 }), n.createIndex("path", "path", { unique: !1 });
+};
+
+// libs/mcp-worker/src/lib/database.ts
+var DB_NAME = "user-activity-db";
+var DB_VERSION = 1;
+var STORE_NAME = "user-events";
+async function initDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        store.createIndex("timestamp", "timestamp", { unique: false });
+        store.createIndex("type", "type", { unique: false });
+        store.createIndex("path", "path", { unique: false });
       }
     };
   });
 }
-async function T(l) {
-  const s = (await g()).transaction([h], "readonly").objectStore(h).index("timestamp");
-  return new Promise((n, c) => {
-    const a = s.getAll();
-    a.onsuccess = () => {
-      let r = a.result;
-      l?.type && (r = r.filter((i) => i.type === l.type)), l?.startTime && (r = r.filter((i) => i.timestamp >= l.startTime)), l?.endTime && (r = r.filter((i) => i.timestamp <= l.endTime)), l?.path && (r = r.filter((i) => i.path?.includes(l.path))), r.sort((i, k) => k.timestamp - i.timestamp), l?.limit && (r = r.slice(0, l.limit)), n(r);
-    }, a.onerror = () => c(a.error);
+async function queryEvents(filters) {
+  const db = await initDB();
+  const transaction = db.transaction([STORE_NAME], "readonly");
+  const store = transaction.objectStore(STORE_NAME);
+  const index = store.index("timestamp");
+  return new Promise((resolve, reject) => {
+    const request = index.getAll();
+    request.onsuccess = () => {
+      let events = request.result;
+      if (filters?.type) {
+        events = events.filter((e) => e.type === filters.type);
+      }
+      if (filters?.startTime) {
+        events = events.filter((e) => e.timestamp >= filters.startTime);
+      }
+      if (filters?.endTime) {
+        events = events.filter((e) => e.timestamp <= filters.endTime);
+      }
+      if (filters?.path) {
+        events = events.filter((e) => e.path?.includes(filters.path));
+      }
+      events.sort((a, b) => b.timestamp - a.timestamp);
+      if (filters?.limit) {
+        events = events.slice(0, filters.limit);
+      }
+      resolve(events);
+    };
+    request.onerror = () => reject(request.error);
   });
 }
 export {
-  W as WorkerClient,
-  T as queryEvents
+  WorkerClient,
+  queryEvents
 };