@mcp-fe/mcp-worker 0.0.5 → 0.0.7

package/{src/index.ts → index.d.ts}

@@ -1,2 +1,3 @@
 export * from './lib/worker-client';
 export { queryEvents, type UserEvent } from './lib/database';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../libs/mcp-worker/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/index.js

@@ -0,0 +1,255 @@
+class W {
+  serviceWorkerRegistration = null;
+  sharedWorker = null;
+  sharedWorkerPort = null;
+  workerType = null;
+  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;
+        }
+        if (typeof SharedWorker < "u")
+          try {
+            if (this.sharedWorker = new SharedWorker("/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 (o) {
+                console.warn("[WorkerClient] Immediate postMessage to SharedWorker failed (will retry after init):", o);
+              }
+            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"));
+                }
+              }, 2e3), a = this.sharedWorkerPort;
+              if (!a)
+                return clearTimeout(c), s(new Error("SharedWorker port not available"));
+              a.onmessage = (r) => {
+                try {
+                  const i = r.data;
+                  i && i.type === "CONNECTION_STATUS" && (clearTimeout(c), n = !0, this.workerType = "shared", a.onmessage = null, o());
+                } catch {
+                }
+              };
+            });
+            const t = this.sharedWorkerPort;
+            if (this.pendingAuthToken && t)
+              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);
+              }
+            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 {
+                    }
+                  });
+                }
+              } catch {
+              }
+            }), console.log("[WorkerClient] Using SharedWorker");
+            return;
+          } catch (t) {
+            console.warn("[WorkerClient] SharedWorker not available, falling back to ServiceWorker:", t);
+          }
+        console.log("this should not be called"), await this.initServiceWorkerFallback(), this.pendingAuthToken && this.workerType === "service" && (this.sendAuthTokenToServiceWorker(this.pendingAuthToken), this.pendingAuthToken = null);
+      } finally {
+        this.initPromise = null;
+      }
+    })(), 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;
+        }
+        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) => {
+          try {
+            const s = o.data;
+            if (s && s.type === "CONNECTION_STATUS") {
+              const n = !!s.connected;
+              this.connectionStatusCallbacks.forEach((c) => {
+                try {
+                  c(n);
+                } catch {
+                }
+              });
+            }
+          } catch {
+          }
+        }, navigator.serviceWorker.addEventListener("message", this.serviceWorkerMessageHandler);
+      } catch (e) {
+        throw console.error("[WorkerClient] Failed to register ServiceWorker:", e), e;
+      }
+    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);
+        };
+        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)));
+        }
+      });
+    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);
+        };
+        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)));
+        }
+      });
+    }
+    throw new Error("No worker registered");
+  }
+  // Fire-and-forget postMessage (no response expected)
+  async post(e, t) {
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
+      try {
+        this.sharedWorkerPort.postMessage({ type: e, ...t || {} });
+      } catch (o) {
+        console.error("[WorkerClient] Failed to post to SharedWorker:", o);
+      }
+      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);
+      }
+      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);
+      }
+      return;
+    }
+    if (e === "SET_AUTH_TOKEN" && t) {
+      const o = t.token;
+      typeof o == "string" && (this.pendingAuthToken = o);
+    }
+  }
+  sendAuthTokenToServiceWorker(e) {
+    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);
+      }
+    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);
+      }
+    else
+      this.pendingAuthToken = e;
+  }
+  // Subscription API for consumers to listen for connection status updates
+  onConnectionStatus(e) {
+    this.connectionStatusCallbacks.add(e);
+  }
+  offConnectionStatus(e) {
+    this.connectionStatusCallbacks.delete(e);
+  }
+  async getConnectionStatus() {
+    try {
+      const e = await this.request("GET_CONNECTION_STATUS", void 0, 2e3);
+      return e && typeof e == "object" && "connected" in e, !!e.connected;
+    } catch {
+      return !1;
+    }
+  }
+  setAuthToken(e) {
+    if (this.pendingAuthToken = e, 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);
+      }
+    else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(e), this.pendingAuthToken = null);
+  }
+}
+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 });
+      }
+    };
+  });
+}
+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);
+  });
+}
+export {
+  W as WorkerClient,
+  T as queryEvents
+};

package/lib/database.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IndexedDB operations for storing and querying user events
+ */
+export interface UserEvent {
+    id: string;
+    type: 'navigation' | 'click' | 'input' | 'custom';
+    timestamp: number;
+    path?: string;
+    from?: string;
+    to?: string;
+    element?: string;
+    elementId?: string;
+    elementClass?: string;
+    elementText?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface EventFilters {
+    type?: string;
+    startTime?: number;
+    endTime?: number;
+    path?: string;
+    limit?: number;
+}
+export declare function initDB(): Promise<IDBDatabase>;
+export declare function storeEvent(event: Omit<UserEvent, 'id'>): Promise<void>;
+export declare function queryEvents(filters?: EventFilters): Promise<UserEvent[]>;
+//# sourceMappingURL=database.d.ts.map

package/lib/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/database.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,YAAY,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAA;IACjD,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAGD,wBAAsB,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,CAiBnD;AAGD,wBAAsB,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA8B5E;AAGD,wBAAsB,WAAW,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAqC9E"}

package/lib/mcp-controller.d.ts

@@ -0,0 +1,22 @@
+import { queryEvents, UserEvent } from './database';
+export type BroadcastFn = (message: unknown) => void;
+export declare class MCPController {
+    private backendUrl;
+    private broadcastFn;
+    private socket;
+    private transport;
+    private reconnectAttempts;
+    private authToken;
+    private keepAliveInterval;
+    private requireAuth;
+    constructor(backendUrl: string, broadcastFn: BroadcastFn, requireAuth?: boolean);
+    private startKeepAlive;
+    private stopKeepAlive;
+    connectWebSocket(): Promise<void>;
+    setAuthToken(token: string | null): void;
+    handleStoreEvent(userEvent: UserEvent): Promise<void>;
+    handleGetEvents(): Promise<ReturnType<typeof queryEvents>>;
+    getConnectionStatus(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=mcp-controller.d.ts.map

package/lib/mcp-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-controller.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/mcp-controller.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,EAAc,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAOhE,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAErD,qBAAa,aAAa;IAQZ,OAAO,CAAC,UAAU;IAAU,OAAO,CAAC,WAAW;IAP3D,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,iBAAiB,CAA+C;IACxE,OAAO,CAAC,WAAW,CAAU;gBAET,UAAU,EAAE,MAAM,EAAU,WAAW,EAAE,WAAW,EAAE,WAAW,UAAO;IAI5F,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,aAAa;IAOR,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAyGvC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAkBlC,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IAIhE,mBAAmB,IAAI,OAAO;IAI9B,OAAO,IAAI,IAAI;CAWvB"}

package/lib/mcp-server.d.ts

@@ -0,0 +1,36 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare const mcpServer: Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=mcp-server.d.ts.map

package/lib/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/mcp-server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAA;AAMlE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUrB,CAAA"}

package/lib/service-worker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Service Worker MCP Server
+ *
+ * This service worker acts as an MCP (Model Context Protocol) server,
+ * storing user events and exposing them via MCP protocol endpoints.
+ */
+export {};
+//# sourceMappingURL=service-worker.d.ts.map

package/lib/service-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-worker.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/service-worker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/lib/shared-worker.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SharedWorker MCP Server
+ *
+ * This SharedWorker acts as an MCP (Model Context Protocol) server,
+ * storing user events and exposing them via MCP protocol endpoints.
+ * Falls back to ServiceWorker if SharedWorker is not supported.
+ */
+export {};
+//# sourceMappingURL=shared-worker.d.ts.map

package/lib/shared-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-worker.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/shared-worker.ts"],"names":[],"mappings":"AACA;;;;;;GAMG"}

package/lib/websocket-transport.d.ts

@@ -0,0 +1,16 @@
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Custom MCP Transport for WebSocket in Service Worker
+ */
+export declare class WebSocketTransport implements Transport {
+    private ws;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(ws: WebSocket);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=websocket-transport.d.ts.map

package/lib/websocket-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-transport.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/websocket-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE;;GAEG;AACH,qBAAa,kBAAmB,YAAW,SAAS;IAMtC,OAAO,CAAC,EAAE;IAJtB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;gBAE1B,EAAE,EAAE,SAAS;IAE3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBtB,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/lib/worker-client.d.ts

@@ -0,0 +1,20 @@
+export declare class WorkerClient {
+    private serviceWorkerRegistration;
+    private sharedWorker;
+    private sharedWorkerPort;
+    private workerType;
+    private pendingAuthToken;
+    private connectionStatusCallbacks;
+    private serviceWorkerMessageHandler;
+    private initPromise;
+    init(registration?: ServiceWorkerRegistration): Promise<void>;
+    private initServiceWorkerFallback;
+    request<T = any>(type: string, payload?: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+    post(type: string, payload?: Record<string, unknown>): Promise<void>;
+    private sendAuthTokenToServiceWorker;
+    onConnectionStatus(cb: (connected: boolean) => void): void;
+    offConnectionStatus(cb: (connected: boolean) => void): void;
+    getConnectionStatus(): Promise<boolean>;
+    setAuthToken(token: string): void;
+}
+//# sourceMappingURL=worker-client.d.ts.map

package/lib/worker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-client.d.ts","sourceRoot":"","sources":["../../../../libs/mcp-worker/src/lib/worker-client.ts"],"names":[],"mappings":"AAEA,qBAAa,YAAY;IACvB,OAAO,CAAC,yBAAyB,CAA0C;IAC3E,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,gBAAgB,CAAuB;IAE/C,OAAO,CAAC,yBAAyB,CAAgD;IACjF,OAAO,CAAC,2BAA2B,CAA6C;IAGhF,OAAO,CAAC,WAAW,CAA8B;IAGpC,IAAI,CAAC,YAAY,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;YAsI5D,yBAAyB;IA4C1B,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,SAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAoF/F,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCjF,OAAO,CAAC,4BAA4B;IAoB7B,kBAAkB,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAI1D,mBAAmB,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAIrD,mBAAmB,IAAI,OAAO,CAAC,OAAO,CAAC;IAU7C,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAiBzC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/mcp-worker",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "private": false,
   "type": "module",
   "main": "./index.js",

package/eslint.config.mjs

@@ -1,22 +0,0 @@
-import baseConfig from '../../eslint.config.mjs';
-
-export default [
-  ...baseConfig,
-  {
-    files: ['**/*.json'],
-    rules: {
-      '@nx/dependency-checks': [
-        'error',
-        {
-          ignoredFiles: [
-            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
-            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
-          ],
-        },
-      ],
-    },
-    languageOptions: {
-      parser: await import('jsonc-eslint-parser'),
-    },
-  },
-];

package/project.json

@@ -1,9 +0,0 @@
-{
-  "name": "mcp-worker",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/mcp-worker/src",
-  "projectType": "library",
-  "tags": [],
-  "// targets": "to see all targets run: nx show project mcp-worker --web",
-  "targets": {}
-}

package/src/lib/database.ts

@@ -1,122 +0,0 @@
-/**
- * IndexedDB operations for storing and querying user events
- */
-
-const DB_NAME = 'user-activity-db'
-const DB_VERSION = 1
-const STORE_NAME = 'user-events'
-
-export interface UserEvent {
-  id: string
-  type: 'navigation' | 'click' | 'input' | 'custom'
-  timestamp: number
-  path?: string
-  from?: string
-  to?: string
-  element?: string
-  elementId?: string
-  elementClass?: string
-  elementText?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface EventFilters {
-  type?: string
-  startTime?: number
-  endTime?: number
-  path?: string
-  limit?: number
-}
-
-// Initialize IndexedDB
-export async function initDB(): Promise<IDBDatabase> {
-  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 as IDBOpenDBRequest).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 })
-      }
-    }
-  })
-}
-
-// Store event in IndexedDB
-export async function storeEvent(event: Omit<UserEvent, 'id'>): Promise<void> {
-  const db = await initDB()
-  const transaction = db.transaction([STORE_NAME], 'readwrite')
-  const store = transaction.objectStore(STORE_NAME)
-
-  const eventWithId: UserEvent = {
-    ...event,
-    id: `${event.timestamp}-${Math.random().toString(36).substr(2, 9)}`,
-  }
-
-  await new Promise<void>((resolve, reject) => {
-    const request = store.add(eventWithId)
-    request.onsuccess = () => resolve()
-    request.onerror = () => reject(request.error)
-  })
-
-  // Clean up old events (keep last 1000 events)
-  const countRequest = store.count()
-  countRequest.onsuccess = () => {
-    if (countRequest.result > 1000) {
-      const index = store.index('timestamp')
-      const getAllRequest = index.getAll()
-      getAllRequest.onsuccess = () => {
-        const events = getAllRequest.result as UserEvent[]
-        events.sort((a, b) => a.timestamp - b.timestamp)
-        const toDelete = events.slice(0, events.length - 1000)
-        toDelete.forEach((event) => store.delete(event.id))
-      }
-    }
-  }
-}
-
-// Query events from IndexedDB
-export async function queryEvents(filters?: EventFilters): Promise<UserEvent[]> {
-  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 as UserEvent[]
-
-      // Apply filters
-      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!))
-      }
-
-      // Sort by timestamp descending (newest first)
-      events.sort((a, b) => b.timestamp - a.timestamp)
-
-      // Apply limit
-      if (filters?.limit) {
-        events = events.slice(0, filters.limit)
-      }
-
-      resolve(events)
-    }
-    request.onerror = () => reject(request.error)
-  })
-}