callix-dialer-widget 2.8.3 → 2.8.4

package/WIDGET-README.md

@@ -160,7 +160,13 @@ aparecia "(--) ----- ----" na aba espelho). Click-to-call com o agente em pausa
 agente sai da pausa, espera o Callix liberá-lo (até 8 s) e disca; se não liberar, a tarefa
 volta à fila. No modo motor, um `dial` recebido em pausa faz o mesmo dentro do motor.
 
-Sem `engineUrl` nada muda: o SDK continua rodando no navegador como sempre.
+Saída confirmada (2.8.4): o widget aguarda o motor e o back-end confirmarem o
+encerramento antes de apagar a credencial local. Se a saída falhar, mostra o erro
+e permite tentar novamente; se o Chromium cair, tenta concluir a limpeza pela API.
+O modo SDK direto também encerra a sessão no back-end. Atualize o widget, o
+back-end e o motor juntos para usar este fluxo.
+
+Sem `engineUrl` o SDK continua rodando no navegador.
 
 ## 🔐 Login e usuário conhecido
 

package/dist-widget/callix-dialer.es.js

@@ -43832,7 +43832,12 @@ class EngineClient {
     const ws = new Impl(engineWsUrl(this.options.url));
     this.ws = ws;
     ws.onopen = () => {
+      var _a2, _b;
       if (this.ws !== ws) return;
+      if (this.pendingLogoffToken !== void 0 && ((_b = (_a2 = this.options).sessionToken) == null ? void 0 : _b.call(_a2)) !== this.pendingLogoffToken) {
+        this.pendingCommands = this.pendingCommands.filter((entry) => entry.command.name !== "logoff");
+        this.rejectWaiters(new EngineAccessError("session-changed", "A sessão mudou antes de confirmar a saída."));
+      }
       this.reconnectDelay = RECONNECT_MIN_MS;
       this.setState({ wsState: "open" });
       const sessionToken = !this.session && this.options.sessionToken ? this.options.sessionToken() : null;
@@ -43889,7 +43894,8 @@ class EngineClient {
       ws.onclose = null;
       ws.close();
     }
-    for (const waiter of this.viewWaiters.splice(0)) clearTimeout(waiter.timer);
+    this.pendingCommands = [];
+    this.rejectWaiters(new Error("a conexão com o motor foi encerrada"));
     this.setState({ wsState: "closed", tabId: null, engaged: false });
   }
   /**
@@ -43951,6 +43957,10 @@ class EngineClient {
           break;
         }
         if (message.code === "session-changed") {
+          if (this.pendingLogoffToken !== void 0) {
+            this.pendingCommands = this.pendingCommands.filter((entry) => entry.command.name !== "logoff");
+            this.rejectWaiters(new EngineAccessError(message.code, message.message));
+          }
           this.session = null;
           this.log("a sessão deste agente foi trocada por um login novo; reconectando com a credencial atual");
           break;
@@ -44014,6 +44024,10 @@ class EngineClient {
    * (é assim que um login novo substitui a sessão de outro navegador).
    */
   setSession(session) {
+    if (this.pendingLogoffToken !== void 0) {
+      this.pendingCommands = this.pendingCommands.filter((entry) => entry.command.name !== "logoff");
+      this.rejectWaiters(new EngineAccessError("session-changed", "Uma sessão nova substituiu o pedido de saída anterior."));
+    }
     this.session = session;
     this.setState({ rejected: null, sessionLost: null });
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
@@ -44042,6 +44056,35 @@ class EngineClient {
   release() {
     this.send({ type: "release" });
   }
+  /** Só confirma a saída quando o host terminou o encerramento do SDK e da sessão. */
+  async logoff(timeoutMs = 4e4) {
+    var _a2, _b;
+    if (this.state.rejected) throw new EngineAccessError(this.state.rejected.code, this.state.rejected.message);
+    this.session = null;
+    this.pendingCommands = [];
+    this.pendingLogoffToken = (_b = (_a2 = this.options).sessionToken) == null ? void 0 : _b.call(_a2);
+    const command = { name: "logoff" };
+    let acknowledged = false;
+    const confirmation = this.waitForView(timeoutMs, (view) => {
+      if (view.loggingOff) {
+        acknowledged = true;
+        return false;
+      }
+      return view.engine === "stopped" || view.engine === "crashed" || acknowledged && Boolean(view.logoffError);
+    }, { fresh: true });
+    this.command(command);
+    try {
+      const view = await confirmation;
+      if (view.logoffError) throw new Error(view.logoffError);
+      if (!acknowledged || view.engine !== "stopped") throw new Error("O motor parou sem confirmar o encerramento da sessão no Callix.");
+    } catch (error2) {
+      if (error2 instanceof EngineAccessError) throw error2;
+      throw new Error(error2 instanceof Error && error2.message !== "o motor não respondeu" ? error2.message : "O motor não confirmou o encerramento da sessão.");
+    } finally {
+      this.pendingCommands = this.pendingCommands.filter((entry) => entry.command !== command);
+      this.pendingLogoffToken = void 0;
+    }
+  }
   command(command) {
     if (this.ws && this.ws.readyState === WebSocket.OPEN && this.state.tabId) {
       this.send({ type: "command", command });
@@ -60362,6 +60405,27 @@ function AuthenticatedMiniDialer({
     )
   ] });
 }
+async function endUserSdkSession(apiUrl, token, timeoutMs = 2e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(apiUrl, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${token}`, "x-session-token": token },
+      credentials: "same-origin",
+      signal: controller.signal
+    });
+    const data = await response.json().catch(() => null);
+    if (!response.ok || (data == null ? void 0 : data.success) === false) {
+      throw new Error((data == null ? void 0 : data.error) || `O Callix não confirmou o encerramento da sessão (${response.status}).`);
+    }
+  } catch (error2) {
+    if (controller.signal.aborted) throw new Error("O Callix não respondeu ao pedido de encerramento da sessão.");
+    throw error2;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 const PROBE_TIMEOUT_MS = 600;
 const TAKEOVER_GRACE_MS = 3e3;
 const TAKEOVER_JITTER_MS = 600;
@@ -60814,7 +60878,7 @@ function ClickToCallAgent({ enabled = true, pollIntervalMs, sessionToken, onTask
   }, [enabled, pollIntervalMs, sessionToken]);
   return null;
 }
-const WIDGET_VERSION = "2.8.3";
+const WIDGET_VERSION = "2.8.4";
 let currentSipWebSocket = null;
 function sendSipUnregisterIfPossible(ws) {
   if (ws.readyState !== WebSocket.OPEN) return;
@@ -61179,6 +61243,8 @@ function DialerWrapper({ options, containerEl }) {
   const isLoadingRef = useRef(false);
   isLoadingRef.current = isLoading;
   const logoffPendingRef = useRef(false);
+  const logoutInFlightRef = useRef(null);
+  const logoutRetryRef = useRef(false);
   const handleLoginRef = useRef(async () => void 0);
   const handleLogoutRef = useRef(async () => void 0);
   const cancelTakeover = useCallback(() => {
@@ -61223,6 +61289,7 @@ function DialerWrapper({ options, containerEl }) {
         log: (message) => console.log("[Callix Dialer/motor]", message)
       });
       client2.onSessionLost((lost) => {
+        if (logoffPendingRef.current) return;
         const notice = describeSessionDrop(lost.originator);
         setError(`${notice.title}: ${notice.detail}${notice.action ? ` ${notice.action}` : ""}`);
         setIsAuthenticated(false);
@@ -61396,9 +61463,8 @@ function DialerWrapper({ options, containerEl }) {
       }
       if (!view) return;
       setEngineWaiting(false);
-      if (view.engine === "stopped" || view.engine === "crashed") logoffPendingRef.current = false;
       const hasSession = (view.engine === "running" || view.engine === "starting") && !sessionLost;
-      if (hasSession && !logoffPendingRef.current && !isAuthenticatedRef.current && !isLoadingRef.current && !joining) {
+      if (hasSession && !view.loggingOff && !view.logoffError && !logoffPendingRef.current && !isAuthenticatedRef.current && !isLoadingRef.current && !joining) {
         joining = true;
         console.log("[Callix Dialer] o motor já segura a sessão deste agente; entrando por aqui também");
         void joinEngine(user).finally(() => {
@@ -61567,6 +61633,11 @@ function DialerWrapper({ options, containerEl }) {
   }, [engineMode, tabRole, username]);
   const handleLogin = useCallback(async (user) => {
     var _a2, _b, _c, _d;
+    if (logoutInFlightRef.current) return;
+    if (logoutRetryRef.current) {
+      await handleLogoutRef.current({ broadcast: false });
+      if (logoutRetryRef.current) return;
+    }
     setIsLoading(true);
     setError(null);
     setLoginStatus("Preparando login...");
@@ -61585,6 +61656,9 @@ function DialerWrapper({ options, containerEl }) {
           console.log("[Callix Dialer] o motor recusou a credencial desta aba; fazendo login novo que substitui a sessão de lá");
         }
         const domain = engineDomain();
+        if ((view == null ? void 0 : view.loggingOff) || (view == null ? void 0 : view.logoffError) && (view.engine === "running" || view.engine === "starting")) {
+          throw new Error(view.logoffError || "A sessão anterior ainda está sendo encerrada. Aguarde antes de entrar novamente.");
+        }
         const engineHasSession = view !== null && (view.engine === "running" || view.engine === "starting") && !view.sessionLost;
         let token = null;
         if (engineHasSession) {
@@ -61800,54 +61874,116 @@ function DialerWrapper({ options, containerEl }) {
   useEffect(() => {
     handleLoginRef.current = handleLogin;
   }, [handleLogin]);
-  const handleLogout = useCallback(async (opts) => {
-    var _a2, _b;
+  const handleLogout = useCallback((opts) => {
+    if (logoutInFlightRef.current) return logoutInFlightRef.current;
     const broadcast = (opts == null ? void 0 : opts.broadcast) !== false;
     const keepDecision = (opts == null ? void 0 : opts.keepDecision) === true;
     const currentUsername = username;
+    const currentToken = sessionToken ?? (currentUsername ? readStoredToken(currentUsername) : null);
+    const ownsSdkSession = tabRoleRef.current === "leader" || isAuthenticatedRef.current;
     cancelTakeover();
-    if (options.engineUrl) {
-      if (isAuthenticatedRef.current) {
-        logoffPendingRef.current = true;
-        (_a2 = engineRef.current) == null ? void 0 : _a2.command({ name: "logoff" });
-      }
-    } else {
-      if (broadcast) (_b = busRef.current) == null ? void 0 : _b.post({ type: "logout" });
-      if (cleanupRef.current) {
-        console.log("[Callix Dialer] 📴 Logout: Chamando goOffline()...");
-        cleanupRef.current.goOffline();
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        console.log("[Callix Dialer] 🛑 Logout: Chamando stop()...");
-        cleanupRef.current.stop();
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-      if (currentUsername) releaseLeader(currentUsername, tabIdRef.current);
-    }
-    setIsAuthenticated(false);
-    setSessionToken(null);
-    setCallixDomain(null);
+    setIsLoading(true);
+    isLoadingRef.current = true;
+    setLoginStatus("Encerrando sessão...");
     setError(null);
-    if (keepDecision) {
-      setTabRole("member");
-      if (currentUsername) saveTabRole(currentUsername, "member");
-      return;
-    }
-    setTabRole(null);
-    clearTabRole();
-    setUsername(presetUsername ?? null);
-    if (typeof window !== "undefined" && currentUsername) {
+    const run = async () => {
+      var _a2, _b;
       try {
-        const STORAGE_KEYS = getStorageKeys(currentUsername);
-        localStorage.removeItem(LAST_USERNAME_KEY);
-        localStorage.removeItem(STORAGE_KEYS.SESSION_TOKEN);
-        localStorage.removeItem(STORAGE_KEYS.DOMAIN);
-        localStorage.removeItem(STORAGE_KEYS.TIMESTAMP);
-        console.log("[Callix Dialer] Sessão removida do localStorage");
+        if (options.engineUrl) {
+          const client2 = engineRef.current;
+          const state = client2 == null ? void 0 : client2.getState();
+          if (!client2) throw new Error("Não há conexão com o motor para confirmar a saída.");
+          if (!(state == null ? void 0 : state.rejected) && !(state == null ? void 0 : state.sessionLost)) {
+            logoffPendingRef.current = true;
+            const finishStoppedSession = async () => {
+              if (!currentToken) throw new Error("O motor parou sem confirmar a saída e esta aba não tem o token da sessão.");
+              const stored = currentUsername ? readStoredToken(currentUsername) : null;
+              if (stored && stored !== currentToken) throw new EngineAccessError("session-changed", "Outra aba substituiu a sessão durante o encerramento.");
+              await endUserSdkSession(options.apiUrl || "/api/user-sdk-session", currentToken);
+            };
+            const isStopped = () => {
+              const view = client2.getState().view;
+              return (view == null ? void 0 : view.engine) === "stopped" || (view == null ? void 0 : view.engine) === "crashed";
+            };
+            if (isStopped()) {
+              await finishStoppedSession();
+            } else {
+              try {
+                await client2.logoff();
+              } catch (err) {
+                if (!isStopped()) throw err;
+                await finishStoppedSession();
+              }
+            }
+          }
+        } else {
+          if (broadcast) (_a2 = busRef.current) == null ? void 0 : _a2.post({ type: "logout" });
+          if (cleanupRef.current) {
+            cleanupRef.current.goOffline();
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            (_b = cleanupRef.current) == null ? void 0 : _b.stop();
+            await new Promise((resolve) => setTimeout(resolve, 500));
+          }
+          if (ownsSdkSession && !keepDecision) {
+            if (!currentToken) throw new Error("Não há token para encerrar a sessão no Callix.");
+            const stored = currentUsername ? readStoredToken(currentUsername) : null;
+            if (stored && stored !== currentToken) throw new EngineAccessError("session-changed", "Outra aba substituiu a sessão durante o encerramento.");
+            await endUserSdkSession(options.apiUrl || "/api/user-sdk-session", currentToken);
+          }
+          if (currentUsername) releaseLeader(currentUsername, tabIdRef.current);
+        }
+        logoutRetryRef.current = false;
+        logoffPendingRef.current = false;
+        setIsAuthenticated(false);
+        setSessionToken(null);
+        currentSessionRef.current.token = null;
+        setCallixDomain(null);
+        if (keepDecision) {
+          setTabRole("member");
+          if (currentUsername) saveTabRole(currentUsername, "member");
+          return;
+        }
+        setTabRole(null);
+        clearTabRole();
+        setUsername(presetUsername ?? null);
+        if (typeof window !== "undefined" && currentUsername && (options.engineUrl || ownsSdkSession)) {
+          try {
+            const STORAGE_KEYS = getStorageKeys(currentUsername);
+            if (localStorage.getItem(STORAGE_KEYS.SESSION_TOKEN) === currentToken) {
+              if (localStorage.getItem(LAST_USERNAME_KEY) === currentUsername) localStorage.removeItem(LAST_USERNAME_KEY);
+              localStorage.removeItem(STORAGE_KEYS.SESSION_TOKEN);
+              localStorage.removeItem(STORAGE_KEYS.DOMAIN);
+              localStorage.removeItem(STORAGE_KEYS.TIMESTAMP);
+            }
+          } catch (err) {
+            console.warn("[Callix Dialer] Não foi possível limpar os dados locais da sessão:", err);
+          }
+        }
       } catch (err) {
-        console.warn("[Callix Dialer] Não foi possível limpar sessão:", err);
+        console.error("[Callix Dialer] Não foi possível confirmar a saída:", err);
+        if (err instanceof EngineAccessError && err.code === "session-changed") {
+          logoutRetryRef.current = false;
+          logoffPendingRef.current = false;
+          setSessionToken(null);
+          setIsAuthenticated(false);
+          setError("A sessão foi substituída por outro login durante a saída. Entre novamente para usar a sessão atual.");
+          return;
+        }
+        logoutRetryRef.current = true;
+        setIsAuthenticated(false);
+        setError(`Não foi possível confirmar a saída: ${err instanceof Error ? err.message : "falha ao encerrar a sessão"}. Ao entrar novamente, o discador tentará concluir o encerramento primeiro.`);
+      } finally {
+        setIsLoading(false);
+        isLoadingRef.current = false;
+        setLoginStatus(null);
       }
-    }
-  }, [username, presetUsername, options.engineUrl, cancelTakeover]);
+    };
+    const completion = run().finally(() => {
+      logoutInFlightRef.current = null;
+    });
+    logoutInFlightRef.current = completion;
+    return completion;
+  }, [username, sessionToken, presetUsername, options.apiUrl, options.engineUrl, cancelTakeover]);
   useEffect(() => {
     handleLogoutRef.current = handleLogout;
   }, [handleLogout]);
@@ -61875,6 +62011,7 @@ function DialerWrapper({ options, containerEl }) {
   const handleSdkSessionDropped = useCallback(
     (originator, notice) => {
       var _a2;
+      if (logoutInFlightRef.current) return;
       const user = username;
       if (user) releaseLeader(user, tabIdRef.current);
       (_a2 = busRef.current) == null ? void 0 : _a2.post({ type: "dropped", originator });