@mcp-fe/mcp-worker 0.0.11 → 0.0.13

package/README.md

@@ -1,11 +1,62 @@
-# mcp-worker
+# @mcp-fe/mcp-worker
 
-This library was generated with [Nx](https://nx.dev).
+This library provides a client adapter and ready-to-use worker scripts for working with MCP (Model Context Protocol).
 
-## Building
+Exports
 
-Run `nx build mcp-worker` to build the library.
+- `index` — the main client module (exports the `workerClient` singleton and related types). Import this in your client application.
+- `mcp-service-worker.js` — Service Worker implementation intended to be registered via `navigator.serviceWorker.register(...)`.
+- `mcp-shared-worker.js` — SharedWorker implementation intended to be started via `new SharedWorker(...)`.
 
-## Running unit tests
+Note: Worker script files (service/shared) must be available on your application's public path so the browser can fetch them (for example `/mcp-service-worker.js` and `/mcp-shared-worker.js`).
 
-Run `nx test mcp-worker` to execute the unit tests via [Vitest](https://vitest.dev/).
+Quick start
+
+1) Make worker files available on your public path
+
+- Copy the worker files (`mcp-service-worker.js`, `mcp-shared-worker.js`) into the folder your webserver serves as public (for example `public/` or `dist/`).
+- Important: the URL used during registration must match the actual location of the files. The `WorkerClient` defaults to `/mcp-shared-worker.js` and `/mcp-service-worker.js`. 
+  If you place them elsewhere, pass the correct URLs to `init`.
+
+3) Import and initialize in your client app
+
+Example (TypeScript):
+
+```ts
+import { workerClient } from '@mcp-fe/mcp-worker';
+
+// Optionally provide custom worker URLs and backend WebSocket URL
+await workerClient.init({
+  sharedWorkerUrl: '/mcp-shared-worker.js',
+  serviceWorkerUrl: '/mcp-service-worker.js',
+  backendWsUrl: 'wss://your-backend.example/ws'
+});
+
+// Set an auth token (if you use authentication)
+workerClient.setAuthToken('Bearer ...');
+
+// Send an event to the worker (fire-and-forget)
+await workerClient.post('STORE_EVENT', { event: { /* ... */ } });
+
+// Request events (request/response)
+const res = await workerClient.request('GET_EVENTS');
+if (res && (res as any).events) {
+  console.log('Events:', (res as any).events);
+}
+```
+
+Alternatively, register the Service Worker yourself and pass the registration to `init`:
+
+```ts
+// register the service worker (e.g. in your app entry file)
+const registration = await navigator.serviceWorker.register('/mcp-service-worker.js');
+await workerClient.init(registration);
+```
+
+Notes & best practices
+
+- `WorkerClient` prefers `SharedWorker` (shared across windows/iframes on the same origin). If `SharedWorker` is not available, it will automatically fall back to `ServiceWorker`.
+- If you need different worker URLs, pass `sharedWorkerUrl` and `serviceWorkerUrl` to `workerClient.init(...)`.
+- Worker scripts must be served from the same origin as your app.
+- Calling `workerClient.setAuthToken(...)` before initialization is allowed: the client will queue the token and send it when a worker becomes available.
+- The default worker URLs are `/mcp-shared-worker.js` and `/mcp-service-worker.js`.

package/index.js

@@ -1,5 +1,10 @@
-import { q as W } from "./database.js";
-class l {
+// libs/mcp-worker/src/lib/worker-client.ts
+var WorkerClient = class {
+  // Configurable worker script URLs (defaults kept for backward compatibility)
+  sharedWorkerUrl = "/mcp-shared-worker.js";
+  serviceWorkerUrl = "/mcp-service-worker.js";
+  // Backend websocket URL to pass into the worker(s)
+  backendWsUrl = "ws://localhost:3001";
   serviceWorkerRegistration = null;
   sharedWorker = null;
   sharedWorkerPort = null;
@@ -7,228 +12,421 @@ class l {
   pendingAuthToken = null;
   // connection status subscribers
   connectionStatusCallbacks = /* @__PURE__ */ new Set();
-  serviceWorkerMessageHandler = null;
   // 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 () => {
-      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);
-          return;
+  // Accept either a ServiceWorkerRegistration OR WorkerInitOptions to configure URLs
+  async init(registrationOrOptions) {
+    let explicitRegistration;
+    const maybeReg = registrationOrOptions;
+    if (maybeReg && typeof maybeReg.scope === "string") {
+      explicitRegistration = registrationOrOptions;
+    } else if (registrationOrOptions) {
+      const opts = registrationOrOptions;
+      if (opts.sharedWorkerUrl)
+        this.sharedWorkerUrl = opts.sharedWorkerUrl;
+      if (opts.serviceWorkerUrl)
+        this.serviceWorkerUrl = opts.serviceWorkerUrl;
+      if (opts.backendWsUrl)
+        this.backendWsUrl = opts.backendWsUrl;
+    }
+    if (this.initPromise) {
+      return this.initPromise.then(async () => {
+        if (explicitRegistration && this.workerType !== "service") {
+          await this.init(explicitRegistration);
         }
-        if (typeof SharedWorker < "u")
+      });
+    }
+    this.initPromise = (async () => {
+      try {
+        if (explicitRegistration) {
+          this.serviceWorkerRegistration = explicitRegistration;
+          this.workerType = "service";
+          console.log(
+            "[WorkerClient] Using ServiceWorker (explicit registration)"
+          );
           try {
-            if (this.sharedWorker = new SharedWorker("/mcp-shared-worker.js", { type: "module" }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), this.pendingAuthToken && this.sharedWorkerPort)
-              try {
-                this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken });
-              } catch (r) {
-                console.warn("[WorkerClient] Immediate postMessage to SharedWorker failed (will retry after init):", r);
-              }
-            this.sharedWorker.onerror = (r) => {
-              console.error("[WorkerClient] SharedWorker error:", r.message || r.error || r), this.workerType !== "shared" && this.initServiceWorkerFallback().catch((i) => {
-                console.error("[WorkerClient] Failed to initialize ServiceWorker fallback:", i);
-              });
-            }, await new Promise((r, i) => {
-              let a = !1;
-              const n = setTimeout(() => {
-                if (!a) {
-                  const o = this.sharedWorkerPort;
-                  o && (o.onmessage = null), i(new Error("SharedWorker initialization timeout"));
-                }
-              }, 2e3), c = this.sharedWorkerPort;
-              if (!c)
-                return clearTimeout(n), i(new Error("SharedWorker port not available"));
-              c.onmessage = (o) => {
-                try {
-                  const s = o.data;
-                  s && s.type === "CONNECTION_STATUS" && (clearTimeout(n), a = !0, this.workerType = "shared", c.onmessage = null, r());
-                } catch {
-                }
-              };
-            });
-            const t = this.sharedWorkerPort;
-            if (this.pendingAuthToken && t)
-              try {
-                t.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken }), this.pendingAuthToken = null;
-              } catch (r) {
-                console.error("[WorkerClient] Failed to send pending auth token to SharedWorker:", r);
-              }
-            t && (t.onmessage = (r) => {
-              try {
-                const i = r.data;
-                if (i && i.type === "CONNECTION_STATUS") {
-                  const a = !!i.connected;
-                  this.connectionStatusCallbacks.forEach((n) => {
-                    try {
-                      n(a);
-                    } catch {
-                    }
-                  });
-                }
-              } catch {
-              }
-            }), console.log("[WorkerClient] Using SharedWorker");
-            return;
-          } catch (t) {
-            console.warn("[WorkerClient] SharedWorker not available, falling back to ServiceWorker:", t);
+            const initMsg = { type: "INIT", backendUrl: this.backendWsUrl };
+            if (this.pendingAuthToken)
+              initMsg["token"] = this.pendingAuthToken;
+            if (this.serviceWorkerRegistration.active) {
+              this.serviceWorkerRegistration.active.postMessage(initMsg);
+            } else if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+              navigator.serviceWorker.controller.postMessage(initMsg);
+            }
+          } catch {
           }
-        console.log("this should not be called"), await this.initServiceWorkerFallback(), this.pendingAuthToken && this.workerType === "service" && (this.sendAuthTokenToServiceWorker(this.pendingAuthToken), this.pendingAuthToken = null);
+          return;
+        }
+        const sharedOk = await this.initSharedWorker();
+        if (sharedOk)
+          return;
+        await this.initServiceWorkerFallback();
       } finally {
         this.initPromise = null;
       }
-    })(), this.initPromise);
+    })();
+    return this.initPromise;
   }
-  async initServiceWorkerFallback() {
-    if (console.log("initServiceWorkerFallback called"), "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");
-          return;
+  async initSharedWorker() {
+    if (typeof SharedWorker === "undefined") {
+      return false;
+    }
+    try {
+      this.sharedWorker = new SharedWorker(this.sharedWorkerUrl, {
+        type: "module"
+      });
+      this.sharedWorkerPort = this.sharedWorker.port;
+      this.sharedWorkerPort.start();
+      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);
+        const p = this.sharedWorkerPort;
+        if (!p) {
+          clearTimeout(timeout);
+          return reject(new Error("SharedWorker port not available"));
         }
-        const t = await navigator.serviceWorker.register("/mcp-service-worker.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 = (r) => {
+        p.onmessage = (ev) => {
           try {
-            const i = r.data;
-            if (i && i.type === "CONNECTION_STATUS") {
-              const a = !!i.connected;
-              this.connectionStatusCallbacks.forEach((n) => {
+            const data = ev.data;
+            if (data && data.type === "CONNECTION_STATUS") {
+              clearTimeout(timeout);
+              resolved = true;
+              this.workerType = "shared";
+              p.onmessage = null;
+              resolve();
+            }
+          } catch {
+          }
+        };
+      });
+      const portAfterInit = this.sharedWorkerPort;
+      if (portAfterInit) {
+        try {
+          const initMsg = { type: "INIT", backendUrl: this.backendWsUrl };
+          if (this.pendingAuthToken)
+            initMsg["token"] = this.pendingAuthToken;
+          portAfterInit.postMessage(initMsg);
+          this.pendingAuthToken = null;
+        } catch (e) {
+          console.warn("[WorkerClient] Failed to send INIT to SharedWorker port:", e);
+        }
+        portAfterInit.onmessage = (ev) => {
+          try {
+            const data = ev.data;
+            if (data && data.type === "CONNECTION_STATUS") {
+              const connected = !!data.connected;
+              this.connectionStatusCallbacks.forEach((cb) => {
                 try {
-                  n(a);
+                  cb(connected);
                 } catch {
                 }
               });
             }
           } catch {
           }
-        }, navigator.serviceWorker.addEventListener("message", this.serviceWorkerMessageHandler);
-      } catch (e) {
-        throw console.error("[WorkerClient] Failed to register ServiceWorker:", e), e;
+        };
+      }
+      console.log("[WorkerClient] Using SharedWorker");
+      return true;
+    } catch (error) {
+      console.warn(
+        "[WorkerClient] SharedWorker not available, falling back to ServiceWorker:",
+        error
+      );
+      return false;
+    }
+  }
+  async initServiceWorkerFallback() {
+    if ("serviceWorker" in navigator) {
+      try {
+        const existingRegistration = await navigator.serviceWorker.getRegistration();
+        if (existingRegistration) {
+          this.serviceWorkerRegistration = existingRegistration;
+          this.workerType = "service";
+          console.log(
+            "[WorkerClient] Using existing ServiceWorker registration"
+          );
+          return;
+        }
+        this.serviceWorkerRegistration = await navigator.serviceWorker.register(
+          this.serviceWorkerUrl
+        );
+        this.workerType = "service";
+        console.log("[WorkerClient] Using MCP ServiceWorker (fallback)");
+        try {
+          const initMsg = { type: "INIT", backendUrl: this.backendWsUrl };
+          if (this.pendingAuthToken)
+            initMsg["token"] = this.pendingAuthToken;
+          if (this.serviceWorkerRegistration.active) {
+            this.serviceWorkerRegistration.active.postMessage(initMsg);
+          } else if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+            navigator.serviceWorker.controller.postMessage(initMsg);
+          }
+          this.pendingAuthToken = null;
+        } catch {
+        }
+      } 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, r = 5e3) {
-    if (this.workerType === "shared" && this.sharedWorkerPort)
-      return new Promise((i, a) => {
-        const n = new MessageChannel(), c = setTimeout(() => {
-          n.port1.onmessage = null, a(new Error("Request timeout"));
-        }, r);
-        n.port1.onmessage = (o) => {
-          clearTimeout(c), o.data && o.data.success ? i(o.data) : o.data && o.data.success === !1 ? a(new Error(o.data.error || "Worker error")) : i(o.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 o = this.sharedWorkerPort;
-          if (!o)
-            return clearTimeout(c), a(new Error("SharedWorker port not available"));
-          o.postMessage({ type: e, ...t || {} }, [n.port2]);
-        } catch (o) {
-          clearTimeout(c), a(o instanceof Error ? o : new Error(String(o)));
+          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 i = this.serviceWorkerRegistration;
-      if (!i) throw new Error("Service worker registration missing");
-      if (!i.active && (await navigator.serviceWorker.ready, !i.active))
-        throw new Error("Service worker not active");
-      return new Promise((a, n) => {
-        const c = new MessageChannel(), o = setTimeout(() => {
-          c.port1.onmessage = null, n(new Error("Request timeout"));
-        }, r);
-        c.port1.onmessage = (s) => {
-          clearTimeout(o), s.data && s.data.success ? a(s.data) : s.data && s.data.success === !1 ? n(new Error(s.data.error || "Worker error")) : a(s.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 s = i.active;
-          if (!s)
-            return clearTimeout(o), n(new Error("Service worker active instance not available"));
-          s.postMessage({ type: e, ...t || {} }, [c.port2]);
-        } catch (s) {
-          clearTimeout(o), n(s instanceof Error ? s : new Error(String(s)));
+          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 (r) {
-        console.error("[WorkerClient] Failed to post to SharedWorker:", r);
+        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 (r) {
-        console.error("[WorkerClient] Failed to post to ServiceWorker (active):", r);
+        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 (r) {
-        console.error("[WorkerClient] Failed to post to ServiceWorker.controller:", r);
+        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 r = t.token;
-      typeof r == "string" && (this.pendingAuthToken = r);
+    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 {
+    }
   }
+};
+
+// 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 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);
+  });
 }
+
+// libs/mcp-worker/src/index.ts
+var workerClient = new WorkerClient();
 export {
-  l as WorkerClient,
-  W as queryEvents
+  queryEvents,
+  workerClient
 };
-//# sourceMappingURL=index.js.map