obi-sdk 0.6.5 → 0.6.6

package/dist/core/types.d.ts

@@ -18,9 +18,9 @@ export declare const ObiSDKConfigSchema: z.ZodObject<{
         metadata?: any;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    debug: boolean;
     enableVoice: boolean;
     enableScreenCapture: boolean;
-    debug: boolean;
     apiKey?: string | undefined;
     user?: {
         id: string;
@@ -29,9 +29,9 @@ export declare const ObiSDKConfigSchema: z.ZodObject<{
     } | undefined;
 }, {
     apiKey?: string | undefined;
+    debug?: boolean | undefined;
     enableVoice?: boolean | undefined;
     enableScreenCapture?: boolean | undefined;
-    debug?: boolean | undefined;
     user?: {
         id: string;
         email?: string | undefined;

package/dist/modular/chunks/index-d7a5d2f6.js

@@ -0,0 +1,6 @@
+import { O } from "./obi-widget-94e8c026.js";
+import "./types-e0297e7b.js";
+export {
+  O as ObiWidget
+};
+//# sourceMappingURL=index-d7a5d2f6.js.map

package/dist/modular/chunks/index-d7a5d2f6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-d7a5d2f6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/modular/chunks/{obi-widget-9e8ccac7.js → obi-widget-94e8c026.js}

@@ -497,6 +497,11 @@ class ObiClient {
       params: { path: { id } }
     });
   }
+  async startSession(id, token) {
+    return await this.client.GET("/sessions/{id}/start-session", {
+      params: { path: { id }, query: token ? { token } : {} }
+    });
+  }
   async getSessionRecording(id) {
     return await this.client.GET("/sessions/{id}/recording", {
       params: { path: { id } }
@@ -10108,53 +10113,6 @@ function n$2(t2) {
 function r$1(r2) {
   return n$2({ ...r2, state: true, attribute: false });
 }
-class StorageManager {
-  /**
-   * Create a new StorageManager with a specific namespace
-   * @param namespace The namespace to prefix all keys with
-   */
-  constructor(namespace) {
-    this.namespace = namespace;
-  }
-  /**
-   * Get a value from localStorage with the namespace prefix
-   * @param key The key to retrieve
-   * @returns The stored value or null if not found
-   */
-  getItem(key) {
-    return localStorage.getItem(`${this.namespace}.${key}`);
-  }
-  /**
-   * Set a value in localStorage with the namespace prefix
-   * @param key The key to set
-   * @param value The value to store
-   */
-  setItem(key, value) {
-    localStorage.setItem(`${this.namespace}.${key}`, value);
-  }
-  /**
-   * Remove a value from localStorage with the namespace prefix
-   * @param key The key to remove
-   */
-  removeItem(key) {
-    localStorage.removeItem(`${this.namespace}.${key}`);
-  }
-  /**
-   * Clear all keys that belong to this namespace
-   */
-  clear() {
-    for (let i3 = 0; i3 < localStorage.length; i3++) {
-      const key = localStorage.key(i3);
-      if (key && key.startsWith(`${this.namespace}.`)) {
-        localStorage.removeItem(key);
-      }
-    }
-  }
-}
-const STORAGE_KEYS = {
-  SESSION_DATA: "session_data"
-};
-const storage = new StorageManager("io.obi.widget");
 const DEBUG_BUILD$2 = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
 const SDK_VERSION = "9.23.0";
 const GLOBAL_OBJ = globalThis;
@@ -16016,6 +15974,53 @@ function withComponentErrorTracking(componentName) {
     }
   };
 }
+class StorageManager {
+  /**
+   * Create a new StorageManager with a specific namespace
+   * @param namespace The namespace to prefix all keys with
+   */
+  constructor(namespace) {
+    this.namespace = namespace;
+  }
+  /**
+   * Get a value from localStorage with the namespace prefix
+   * @param key The key to retrieve
+   * @returns The stored value or null if not found
+   */
+  getItem(key) {
+    return localStorage.getItem(`${this.namespace}.${key}`);
+  }
+  /**
+   * Set a value in localStorage with the namespace prefix
+   * @param key The key to set
+   * @param value The value to store
+   */
+  setItem(key, value) {
+    localStorage.setItem(`${this.namespace}.${key}`, value);
+  }
+  /**
+   * Remove a value from localStorage with the namespace prefix
+   * @param key The key to remove
+   */
+  removeItem(key) {
+    localStorage.removeItem(`${this.namespace}.${key}`);
+  }
+  /**
+   * Clear all keys that belong to this namespace
+   */
+  clear() {
+    for (let i3 = 0; i3 < localStorage.length; i3++) {
+      const key = localStorage.key(i3);
+      if (key && key.startsWith(`${this.namespace}.`)) {
+        localStorage.removeItem(key);
+      }
+    }
+  }
+}
+const STORAGE_KEYS = {
+  SESSION_DATA: "session_data"
+};
+const storage = new StorageManager("io.obi.widget");
 var __defProp$7 = Object.defineProperty;
 var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
 var __decorateClass$7 = (decorators, target, key, kind) => {
@@ -17601,199 +17606,245 @@ class ObiWidget extends i$1 {
     this.obiClient = null;
     this.closeNavTimeoutRef = null;
     this.researchingTimeoutRef = null;
-    this.connectObi = withSentryAsyncHandler(async (sessionToken) => {
-      if (this.activeSession) {
-        trackEvent("connection_already_exists", { sessionToken }, "ObiWidget");
-        console.log("Connection already exists");
-        return;
-      }
-      trackEvent("session_connection_started", { sessionToken }, "ObiWidget");
-      setGlobalContext({ sessionId: sessionToken });
-      try {
-        const session = this.createSession(sessionToken);
-        if (!session) {
-          this.handleSessionCreationFailure(() => this.removeSessionUrlParams());
+    this.connectObi = withSentryAsyncHandler(
+      async (sessionToken) => {
+        if (this.activeSession) {
+          trackEvent("connection_already_exists", { sessionToken }, "ObiWidget");
+          console.log("Connection already exists");
           return;
         }
-        this.setupSessionEventListeners(session, () => this.removeSessionUrlParams());
-        session.on("screenCaptureRequested", withSentryAsyncHandler(async () => {
-          trackEvent("screen_capture_requested", {}, "ObiWidget");
-          try {
-            const canvas = await html2canvas(document.documentElement, {
-              useCORS: true,
-              allowTaint: true,
-              foreignObjectRendering: true
-            });
-            const dataUrl = canvas.toDataURL("image/png");
-            this.activeSession.emit("screenCaptureComplete", dataUrl);
-            trackEvent("screen_capture_completed", {}, "ObiWidget");
-          } catch (e2) {
-            captureException(e2, {
-              componentName: "ObiWidget",
-              handlerName: "screenCaptureRequested",
-              sessionToken
+        trackEvent("session_connection_started", { sessionToken }, "ObiWidget");
+        setGlobalContext({ sessionId: sessionToken });
+        try {
+          const session = this.createSession(sessionToken);
+          if (!session) {
+            this.handleSessionCreationFailure(() => this.removeSessionUrlParams());
+            return;
+          }
+          this.setupSessionEventListeners(session, () => this.removeSessionUrlParams());
+          session.on(
+            "screenCaptureRequested",
+            withSentryAsyncHandler(
+              async () => {
+                trackEvent("screen_capture_requested", {}, "ObiWidget");
+                try {
+                  const canvas = await html2canvas(document.documentElement, {
+                    useCORS: true,
+                    allowTaint: true,
+                    foreignObjectRendering: true
+                  });
+                  const dataUrl = canvas.toDataURL("image/png");
+                  this.activeSession.emit("screenCaptureComplete", dataUrl);
+                  trackEvent("screen_capture_completed", {}, "ObiWidget");
+                } catch (e2) {
+                  captureException(e2, {
+                    componentName: "ObiWidget",
+                    handlerName: "screenCaptureRequested",
+                    sessionToken
+                  });
+                  console.error("[obi] error capturing screen:", e2);
+                  this.activeSession.emit("screenCaptureComplete", "error");
+                  trackEvent(
+                    "screen_capture_failed",
+                    {
+                      error: e2 instanceof Error ? e2.message : String(e2)
+                    },
+                    "ObiWidget"
+                  );
+                }
+              },
+              "screenCaptureRequested",
+              "ObiWidget"
+            )
+          );
+          const connectionInfo = await session.connect();
+          if (connectionInfo) {
+            this.sessionToken = sessionToken;
+            this.roomToken = connectionInfo.token;
+            this.roomUrl = connectionInfo.url;
+            setGlobalContext({
+              sessionId: sessionToken,
+              widgetState: this.state.toString()
             });
-            console.error("[obi] error capturing screen:", e2);
-            this.activeSession.emit("screenCaptureComplete", "error");
-            trackEvent("screen_capture_failed", {
-              error: e2 instanceof Error ? e2.message : String(e2)
-            }, "ObiWidget");
+            this.removeSessionUrlParams();
+            trackEvent(
+              "session_connection_established",
+              {
+                sessionToken,
+                hasRoomToken: !!connectionInfo.token
+              },
+              "ObiWidget"
+            );
           }
-        }, "screenCaptureRequested", "ObiWidget"));
-        const connectionInfo = await session.connect();
-        if (connectionInfo) {
-          this.sessionToken = sessionToken;
-          this.roomToken = connectionInfo.token;
-          this.roomUrl = connectionInfo.url;
-          setGlobalContext({
-            sessionId: sessionToken,
-            widgetState: this.state.toString()
+          this.activeSession = session;
+        } catch (error) {
+          console.error("Failed to start session:", error);
+          captureException(error, {
+            componentName: "ObiWidget",
+            handlerName: "connectObi",
+            sessionToken
           });
-          this.removeSessionUrlParams();
-          trackEvent("session_connection_established", {
-            sessionToken,
-            hasRoomToken: !!connectionInfo.token
-          }, "ObiWidget");
+          this.handleSessionCreationFailure(() => this.removeSessionUrlParams());
         }
-        this.activeSession = session;
-      } catch (error) {
-        console.error("Failed to start session:", error);
-        captureException(error, {
-          componentName: "ObiWidget",
-          handlerName: "connectObi",
-          sessionToken
-        });
-        this.handleSessionCreationFailure(() => this.removeSessionUrlParams());
-      }
-    }, "connectObi", "ObiWidget");
+      },
+      "connectObi",
+      "ObiWidget"
+    );
     this.handleCourseSelectEvent = (event) => {
       const customEvent = event;
       this.selectedCourse = customEvent.detail;
       this.showCourseModal = false;
       this.showSessionStartModal = true;
     };
-    this.handleUrlSessionEvent = withSentryAsyncHandler(async (sessionToken) => {
-      trackEvent("url_session_event", { sessionToken }, "ObiWidget");
-      try {
-        if (!this.obiClient) {
-          const error = new Error("ObiClient not initialized");
+    this.handleUrlSessionEvent = withSentryAsyncHandler(
+      async (sessionToken) => {
+        trackEvent("url_session_event", { sessionToken }, "ObiWidget");
+        try {
+          if (!this.obiClient) {
+            const error = new Error("ObiClient not initialized");
+            captureException(error, {
+              componentName: "ObiWidget",
+              handlerName: "handleUrlSessionEvent",
+              sessionToken
+            });
+            console.error("ObiClient not initialized");
+            return;
+          }
+          const sessionsResponse = await this.obiClient.startSession(sessionToken, this.apiKey);
+          if (sessionsResponse.data) {
+            const { session } = sessionsResponse.data;
+            console.log("[obi-sdk] session:", session);
+            trackEvent(
+              "session_started",
+              {
+                sessionId: session?.id,
+                sessionToken
+              },
+              "ObiWidget"
+            );
+            if (session) {
+              const sessionWithPlan = session;
+              this.selectedCourse = {
+                id: sessionToken,
+                name: sessionWithPlan.onboarding_plan?.name || "",
+                description: sessionWithPlan.onboarding_plan?.description || ""
+              };
+              this.state = SDKState.LOADING;
+              this.showSessionStartModal = true;
+              trackEvent(
+                "matching_session_found",
+                {
+                  sessionToken,
+                  hasOnboardingPlan: !!sessionWithPlan.onboarding_plan
+                },
+                "ObiWidget"
+              );
+            } else {
+              console.log("[obi-sdk] no session found with token:", sessionToken);
+              trackEvent("no_matching_session", { sessionToken }, "ObiWidget");
+            }
+          }
+        } catch (error) {
+          console.error("Failed to fetch session details:", error);
           captureException(error, {
             componentName: "ObiWidget",
             handlerName: "handleUrlSessionEvent",
             sessionToken
           });
-          console.error("ObiClient not initialized");
+        }
+      },
+      "handleUrlSessionEvent",
+      "ObiWidget"
+    );
+    this.handleSessionStart = withSentryAsyncHandler(
+      async (sessionToken) => {
+        trackEvent("session_start_requested", { sessionToken }, "ObiWidget");
+        if (this.activeSession) {
+          trackEvent("session_start_blocked", { sessionToken }, "ObiWidget");
+          console.log("Connection already in progress or active session exists");
           return;
         }
-        const sessionsResponse = await this.obiClient.listSessions(this.apiKey);
-        if (sessionsResponse.data) {
-          const sessions = sessionsResponse.data.sessions;
-          console.log("[obi-sdk] sessions:", sessions);
-          trackEvent("sessions_fetched", {
-            sessionCount: sessions?.length || 0,
-            sessionToken
-          }, "ObiWidget");
-          const matchingSession = sessions?.find((session) => session.uuid === sessionToken);
-          if (matchingSession) {
-            const sessionWithPlan = matchingSession;
-            this.selectedCourse = {
-              id: sessionToken,
-              name: sessionWithPlan.onboarding_plan?.name || "",
-              description: sessionWithPlan.onboarding_plan?.description || ""
-            };
-            this.state = SDKState.LOADING;
-            this.showSessionStartModal = true;
-            trackEvent("matching_session_found", {
+        this.showSessionStartModal = false;
+        this.state = SDKState.LOADING;
+        setGlobalContext({ widgetState: this.state.toString() });
+        await this.connectObi(sessionToken);
+      },
+      "handleSessionStart",
+      "ObiWidget"
+    );
+    this.checkExistingSession = withSentryAsyncHandler(
+      async () => {
+        trackEvent("checking_existing_session", {}, "ObiWidget");
+        try {
+          const sessionData = JSON.parse(
+            storage.getItem(STORAGE_KEYS.SESSION_DATA) || "{}"
+          );
+          const { sessionToken, roomToken, roomUrl, sessionExpiry, obiState } = sessionData;
+          if (!sessionToken || !roomToken || !roomUrl) {
+            trackEvent("no_existing_session_data", {}, "ObiWidget");
+            return;
+          }
+          console.log("[obi-sdk] using existing session");
+          trackEvent(
+            "existing_session_data_found",
+            {
               sessionToken,
-              hasOnboardingPlan: !!sessionWithPlan.onboarding_plan
-            }, "ObiWidget");
-          } else {
-            console.log("[obi-sdk] no session found with token:", sessionToken);
-            trackEvent("no_matching_session", { sessionToken }, "ObiWidget");
+              hasExpiry: !!sessionExpiry,
+              obiState
+            },
+            "ObiWidget"
+          );
+          if (sessionExpiry) {
+            const expiryDate = new Date(sessionExpiry);
+            if (expiryDate < /* @__PURE__ */ new Date()) {
+              this.clearSessionStorage();
+              trackEvent("session_expired", { sessionToken }, "ObiWidget");
+              return;
+            }
           }
-        }
-      } catch (error) {
-        console.error("Failed to fetch session details:", error);
-        captureException(error, {
-          componentName: "ObiWidget",
-          handlerName: "handleUrlSessionEvent",
-          sessionToken
-        });
-      }
-    }, "handleUrlSessionEvent", "ObiWidget");
-    this.handleSessionStart = withSentryAsyncHandler(async (sessionToken) => {
-      trackEvent("session_start_requested", { sessionToken }, "ObiWidget");
-      if (this.activeSession) {
-        trackEvent("session_start_blocked", { sessionToken }, "ObiWidget");
-        console.log("Connection already in progress or active session exists");
-        return;
-      }
-      this.showSessionStartModal = false;
-      this.state = SDKState.LOADING;
-      setGlobalContext({ widgetState: this.state.toString() });
-      await this.connectObi(sessionToken);
-    }, "handleSessionStart", "ObiWidget");
-    this.checkExistingSession = withSentryAsyncHandler(async () => {
-      trackEvent("checking_existing_session", {}, "ObiWidget");
-      try {
-        const sessionData = JSON.parse(
-          storage.getItem(STORAGE_KEYS.SESSION_DATA) || "{}"
-        );
-        const { sessionToken, roomToken, roomUrl, sessionExpiry, obiState } = sessionData;
-        if (!sessionToken || !roomToken || !roomUrl) {
-          trackEvent("no_existing_session_data", {}, "ObiWidget");
-          return;
-        }
-        console.log("[obi-sdk] using existing session");
-        trackEvent("existing_session_data_found", {
-          sessionToken,
-          hasExpiry: !!sessionExpiry,
-          obiState
-        }, "ObiWidget");
-        if (sessionExpiry) {
-          const expiryDate = new Date(sessionExpiry);
-          if (expiryDate < /* @__PURE__ */ new Date()) {
-            this.clearSessionStorage();
-            trackEvent("session_expired", { sessionToken }, "ObiWidget");
+          this.state = SDKState.LOADING;
+          setGlobalContext({
+            sessionId: sessionToken,
+            widgetState: this.state.toString()
+          });
+          const session = this.createSession(sessionToken);
+          if (!session) {
+            this.handleSessionCreationFailure(() => this.clearSessionStorage());
             return;
           }
-        }
-        this.state = SDKState.LOADING;
-        setGlobalContext({
-          sessionId: sessionToken,
-          widgetState: this.state.toString()
-        });
-        const session = this.createSession(sessionToken);
-        if (!session) {
+          this.setupSessionEventListeners(session, () => this.clearSessionStorage());
+          const reconnected = await session.reconnect(roomUrl, roomToken, obiState);
+          if (reconnected) {
+            this.activeSession = session;
+            this.sessionToken = sessionToken;
+            this.roomToken = roomToken;
+            this.roomUrl = roomUrl;
+            this.state = obiState;
+            this.storedActiveState = obiState;
+            trackEvent(
+              "session_reconnected",
+              {
+                sessionToken,
+                obiState
+              },
+              "ObiWidget"
+            );
+          } else {
+            this.clearSessionStorage();
+            trackEvent("session_reconnection_failed", { sessionToken }, "ObiWidget");
+          }
+        } catch (error) {
+          console.error("Error reconnecting to session:", error);
+          captureException(error, {
+            componentName: "ObiWidget",
+            handlerName: "checkExistingSession"
+          });
           this.handleSessionCreationFailure(() => this.clearSessionStorage());
-          return;
-        }
-        this.setupSessionEventListeners(session, () => this.clearSessionStorage());
-        const reconnected = await session.reconnect(roomUrl, roomToken, obiState);
-        if (reconnected) {
-          this.activeSession = session;
-          this.sessionToken = sessionToken;
-          this.roomToken = roomToken;
-          this.roomUrl = roomUrl;
-          this.state = obiState;
-          this.storedActiveState = obiState;
-          trackEvent("session_reconnected", {
-            sessionToken,
-            obiState
-          }, "ObiWidget");
-        } else {
-          this.clearSessionStorage();
-          trackEvent("session_reconnection_failed", { sessionToken }, "ObiWidget");
         }
-      } catch (error) {
-        console.error("Error reconnecting to session:", error);
-        captureException(error, {
-          componentName: "ObiWidget",
-          handlerName: "checkExistingSession"
-        });
-        this.handleSessionCreationFailure(() => this.clearSessionStorage());
-      }
-    }, "checkExistingSession", "ObiWidget");
+      },
+      "checkExistingSession",
+      "ObiWidget"
+    );
     try {
       const errorTracker = withComponentErrorTracking("ObiWidget");
       errorTracker.setContext();
@@ -18355,4 +18406,4 @@ export {
   withSentryAsyncHandler as w,
   x
 };
-//# sourceMappingURL=obi-widget-9e8ccac7.js.map
+//# sourceMappingURL=obi-widget-94e8c026.js.map