@kshema/communications-client 0.1.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@kshema/communications-client",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@azure/communication-common": "^2.5.0",
+    "@react-native-async-storage/async-storage": "^3.1.1",
+    "axios": "^1.20.0",
+    "react-native-permissions": "^5.6.2",
+    "react-native-webrtc": "^124.0.8",
+    "socket.io-client": "^4.8.3"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.76.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.3.0",
+    "@types/react-native": "^0.72.8",
+    "typescript": "^5.9.2"
+  }
+}

package/src/core/AcsSessionManager.ts

@@ -0,0 +1,82 @@
+import AsyncStorage from
+  "@react-native-async-storage/async-storage";
+
+import {
+  AcsEvents,
+  SessionData,
+} from "./types";
+
+import {
+  eventEmitter,
+} from "./EventEmitter";
+
+const STORAGE_KEY =
+  "@acs_session";
+
+class AcsSessionManager {
+
+  async save(
+    session: SessionData
+  ) {
+
+    await AsyncStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify(session)
+    );
+
+    eventEmitter.emit(
+      AcsEvents.SESSION_CREATED,
+      session
+    );
+  }
+
+  async get() {
+
+    const value =
+      await AsyncStorage.getItem(
+        STORAGE_KEY
+      );
+
+    if (!value) {
+      return null;
+    }
+
+    return JSON.parse(
+      value
+    ) as SessionData;
+  }
+
+  async clear() {
+
+    await AsyncStorage.removeItem(
+      STORAGE_KEY
+    );
+
+    eventEmitter.emit(
+      AcsEvents.SESSION_CLEARED
+    );
+  }
+
+  async isExpired() {
+
+    const session =
+      await this.get();
+
+    if (!session) {
+      return true;
+    }
+
+    const now =
+      new Date().getTime();
+
+    const expiry =
+      new Date(
+        session.expiresOn
+      ).getTime();
+
+    return now >= expiry;
+  }
+}
+
+export const sessionManager =
+  new AcsSessionManager();

package/src/core/AcsSupport.ts

@@ -0,0 +1,236 @@
+import {
+  AcsConfig,
+  AcsEvents,
+} from "./types";
+
+import {
+  sessionManager,
+} from "./AcsSessionManager";
+
+import {
+  eventEmitter,
+} from "./EventEmitter";
+
+import {
+  TokenService,
+} from "../services/TokenService";
+
+import {
+  PresenceService,
+} from "../services/PresenceService";
+
+import {
+  CallingService,
+} from "../services/CallingService";
+
+import {
+  NotificationService,
+} from "../services/NotificationService";
+
+import {
+  RecordingService,
+} from "../services/RecordingService";
+
+import {
+  RemoteControlService,
+} from "../services/RemoteControlService";
+
+import {
+  socketManager,
+} from "../sockets/socket";
+
+export class AcsSupport {
+
+  private tokenService: TokenService;
+
+  public presence!: PresenceService;
+
+  public calling!: CallingService;
+
+  public notifications!: NotificationService;
+
+  public recordings!: RecordingService;
+
+  public remoteControl!: RemoteControlService;
+
+  constructor(
+    private config: AcsConfig
+  ) {
+    this.tokenService =
+      new TokenService(config);
+  }
+
+  async initialize() {
+
+    let session =
+      await sessionManager.get();
+
+    if (!session) {
+
+      const token =
+        await this.tokenService
+          .generateToken();
+
+      session = {
+        acsUserId:
+          token.acsUserId,
+
+        acsToken:
+          token.token,
+
+        expiresOn:
+          token.expiresOn,
+
+        userId:
+          token.userId,
+      };
+
+      await sessionManager.save(
+        session
+      );
+
+      eventEmitter.emit(
+        AcsEvents.SESSION_CREATED,
+        session
+      );
+    }
+
+    const expired =
+      await sessionManager.isExpired();
+
+    if (expired) {
+
+      eventEmitter.emit(
+        AcsEvents.SESSION_EXPIRED
+      );
+
+      const token =
+        await this.tokenService
+          .generateToken();
+
+      session = {
+        acsUserId:
+          token.acsUserId,
+
+        acsToken:
+          token.token,
+
+        expiresOn:
+          token.expiresOn,
+
+        userId:
+          token.userId,
+      };
+
+      await sessionManager.save(
+        session
+      );
+
+      eventEmitter.emit(
+        AcsEvents.TOKEN_REFRESHED,
+        session
+      );
+    }
+
+    /**
+     * Initialize Services
+     */
+
+    this.presence =
+      new PresenceService(
+        this.config.apiBaseUrl,
+        this.config.jwtToken
+      );
+
+    this.calling =
+      new CallingService(
+        this.config.apiBaseUrl,
+        this.config.jwtToken
+      );
+
+    this.notifications =
+      new NotificationService();
+
+    this.recordings =
+      new RecordingService(
+        this.config.apiBaseUrl,
+        this.config.jwtToken
+      );
+
+    this.remoteControl =
+      new RemoteControlService();
+
+    /**
+     * Connect Socket.IO
+     */
+
+    if (this.config.socketUrl) {
+
+      socketManager.connect(
+        this.config.socketUrl,
+        this.config.jwtToken
+      );
+    }
+
+    /**
+     * Start Heartbeat
+     */
+
+    this.startHeartbeat();
+
+    return session;
+  }
+
+  private startHeartbeat() {
+
+    setInterval(async () => {
+
+      try {
+
+        await this.presence.heartbeat();
+
+      } catch (error) {
+
+        console.error(
+          "Presence heartbeat failed",
+          error
+        );
+      }
+
+    }, 30000);
+  }
+
+  async getSession() {
+
+    return sessionManager.get();
+  }
+
+  async logout() {
+
+    socketManager.disconnect();
+
+    await sessionManager.clear();
+  }
+
+  on(
+    event: string,
+    callback: (...args: any[]) => void
+  ) {
+
+    eventEmitter.on(
+      event,
+      callback
+    );
+  }
+
+  off(
+    event: string,
+    callback: (...args: any[]) => void
+  ) {
+
+    eventEmitter.off(
+      event,
+      callback
+    );
+  }
+}

package/src/core/EventEmitter.ts

@@ -0,0 +1,49 @@
+type EventCallback = (
+  payload?: any
+) => void;
+
+class EventEmitter {
+  private listeners:
+    Record<string, EventCallback[]> = {};
+
+  on(
+    event: string,
+    callback: EventCallback
+  ) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+
+    this.listeners[event].push(
+      callback
+    );
+  }
+
+  emit(
+    event: string,
+    payload?: any
+  ) {
+    const callbacks =
+      this.listeners[event] || [];
+
+    callbacks.forEach(cb =>
+      cb(payload)
+    );
+  }
+
+  off(
+    event: string,
+    callback: EventCallback
+  ) {
+    const callbacks =
+      this.listeners[event] || [];
+
+    this.listeners[event] =
+      callbacks.filter(
+        listener => listener !== callback
+      );
+  }
+}
+
+export const eventEmitter =
+  new EventEmitter();

package/src/core/types.ts

@@ -0,0 +1,44 @@
+export interface AcsTokenResponse {
+    source: "new" | "cached" | "refreshed";
+
+    userId: string;
+
+    username?: string;
+
+    displayName?: string;
+
+    acsUserId: string;
+
+    token: string;
+
+    expiresOn: string;
+}
+
+export interface AcsConfig {
+
+    apiBaseUrl: string;
+
+    jwtToken: string;
+
+    socketUrl?: string;
+}
+
+export interface SessionData {
+    acsUserId: string;
+
+    acsToken: string;
+
+    expiresOn: string;
+
+    userId: string;
+}
+
+export enum AcsEvents {
+    TOKEN_REFRESHED = "TOKEN_REFRESHED",
+
+    SESSION_CREATED = "SESSION_CREATED",
+
+    SESSION_EXPIRED = "SESSION_EXPIRED",
+
+    SESSION_CLEARED = "SESSION_CLEARED",
+}

package/src/hooks/useCall.ts

@@ -0,0 +1,57 @@
+import { useState } from "react";
+
+export const useCall = (
+  support: any
+) => {
+
+  const [call,
+    setCall] =
+      useState<any>(null);
+
+  const createCall =
+    async () => {
+
+      const response =
+        await support
+          .calling
+          .createCall();
+
+      setCall(
+        response.data.call
+      );
+
+      return response;
+    };
+
+  const acceptCall =
+    async (callId: string) => {
+
+      return support
+        .calling
+        .acceptCall(callId);
+    };
+
+  const rejectCall =
+    async (callId: string) => {
+
+      return support
+        .calling
+        .rejectCall(callId);
+    };
+
+  const endCall =
+    async (callId: string) => {
+
+      return support
+        .calling
+        .endCall(callId);
+    };
+
+  return {
+    call,
+    createCall,
+    acceptCall,
+    rejectCall,
+    endCall,
+  };
+};

package/src/hooks/usePresence.ts

@@ -0,0 +1,29 @@
+import { useEffect, useState } from "react";
+
+export const usePresence = (
+  support: any
+) => {
+  const [agents, setAgents] =
+    useState([]);
+
+  const loadAgents =
+    async () => {
+      const response =
+        await support
+          .presence
+          .getAvailableAgents();
+
+      setAgents(
+        response.data || []
+      );
+    };
+
+  useEffect(() => {
+    loadAgents();
+  }, []);
+
+  return {
+    agents,
+    refresh: loadAgents,
+  };
+};

package/src/hooks/useSocket.ts

@@ -0,0 +1,38 @@
+import { useEffect } from "react";
+
+export const useSocket = (
+  support: any,
+  handlers: {
+    onIncomingCall?: (
+      call: any
+    ) => void;
+
+    onCallAccepted?: (
+      call: any
+    ) => void;
+
+    onCallEnded?: (
+      call: any
+    ) => void;
+  }
+) => {
+
+  useEffect(() => {
+
+    support.notifications
+      .listenIncomingCall(
+        handlers.onIncomingCall
+      );
+
+    support.notifications
+      .listenCallAccepted(
+        handlers.onCallAccepted
+      );
+
+    support.notifications
+      .listenCallEnded(
+        handlers.onCallEnded
+      );
+
+  }, []);
+};

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from "./core/AcsSupport";
+export * from "./core/AcsSessionManager";
+export * from "./core/EventEmitter";
+export * from "./core/types";
+
+export * from "./services/PresenceService";
+export * from "./services/CallingService";
+export * from "./services/NotificationService";
+export * from "./services/RecordingService";
+export * from "./services/RemoteControlService";
+
+export * from "./hooks/useCall";
+export * from "./hooks/usePresence";
+export * from "./hooks/useSocket";
+
+export * from "./screens/IncomingCallScreen";
+export * from "./screens/ActiveCallScreen";
+export * from "./screens/ScreenShareScreen";
+export * from "./screens/CallHistoryScreen";

package/src/native/NativeAcsBridge.ts

@@ -0,0 +1,34 @@
+import { NativeModules } from "react-native";
+
+export interface NativeAcsModule {
+  initialize(token: string): Promise<void>;
+
+  joinCall(groupId: string): Promise<void>;
+
+  leaveCall(): Promise<void>;
+
+  mute(): Promise<void>;
+
+  unmute(): Promise<void>;
+
+  startVideo(): Promise<void>;
+
+  stopVideo(): Promise<void>;
+
+  startScreenShare(): Promise<void>;
+
+  stopScreenShare(): Promise<void>;
+
+  startRecording(): Promise<void>;
+
+  stopRecording(): Promise<void>;
+
+  requestRemoteControl(): Promise<void>;
+
+  approveRemoteControl(): Promise<void>;
+
+  denyRemoteControl(): Promise<void>;
+}
+
+export const NativeAcsBridge =
+  NativeModules.KshemaAcsSupport as NativeAcsModule;

package/src/native/RemoteControlSession.ts

@@ -0,0 +1,74 @@
+import { NativeAcsBridge }
+from "./NativeAcsBridge";
+
+export class RemoteControlSession {
+
+  async requestControl() {
+
+    await NativeAcsBridge.requestRemoteControl();
+  }
+
+  async approveControl() {
+
+    await NativeAcsBridge.approveRemoteControl();
+  }
+
+  async denyControl() {
+
+    await NativeAcsBridge.denyRemoteControl();
+  }
+
+  pointerMove(
+    x: number,
+    y: number
+  ) {
+
+    console.log(
+      "POINTER_MOVE",
+      x,
+      y
+    );
+  }
+
+  click(
+    x: number,
+    y: number
+  ) {
+
+    console.log(
+      "CLICK",
+      x,
+      y
+    );
+  }
+
+  scroll(
+    delta: number
+  ) {
+
+    console.log(
+      "SCROLL",
+      delta
+    );
+  }
+
+  keyboardInput(
+    text: string
+  ) {
+
+    console.log(
+      "KEYBOARD_INPUT",
+      text
+    );
+  }
+
+  revokeConsent() {
+
+    console.log(
+      "CONSENT_REVOKED"
+    );
+  }
+}
+
+export const remoteControlSession =
+  new RemoteControlSession();

package/src/native/SupportCallSession.ts

@@ -0,0 +1,80 @@
+import { NativeAcsBridge } from "./NativeAcsBridge";
+
+export class SupportCallSession {
+
+  private callId?: string;
+
+  private groupId?: string;
+
+  async initialize(
+    acsToken: string
+  ) {
+
+    await NativeAcsBridge.initialize(
+      acsToken
+    );
+  }
+
+  async joinCall(
+    groupId: string
+  ) {
+
+    this.groupId = groupId;
+
+    await NativeAcsBridge.joinCall(
+      groupId
+    );
+  }
+
+  async leaveCall() {
+
+    await NativeAcsBridge.leaveCall();
+  }
+
+  async mute() {
+
+    await NativeAcsBridge.mute();
+  }
+
+  async unmute() {
+
+    await NativeAcsBridge.unmute();
+  }
+
+  async startVideo() {
+
+    await NativeAcsBridge.startVideo();
+  }
+
+  async stopVideo() {
+
+    await NativeAcsBridge.stopVideo();
+  }
+
+  async startScreenShare() {
+
+    await NativeAcsBridge.startScreenShare();
+  }
+
+  async stopScreenShare() {
+
+    await NativeAcsBridge.stopScreenShare();
+  }
+
+  async startRecording() {
+
+    await NativeAcsBridge.startRecording();
+  }
+
+  async stopRecording() {
+
+    await NativeAcsBridge.stopRecording();
+  }
+
+  getGroupId() {
+    return this.groupId;
+  }
+}
+
+export const supportCallSession =
+  new SupportCallSession();

package/src/screens/ActiveCallScreen.tsx

@@ -0,0 +1,54 @@
+import React from "react";
+
+import {
+  View,
+  Button,
+} from "react-native";
+
+export default function
+ActiveCallScreen({
+  onMute,
+  onUnmute,
+  onEnd,
+  onVideoOn,
+  onVideoOff,
+  onShareScreen,
+}: any) {
+
+  return (
+    <View>
+
+      <Button
+        title="Mute"
+        onPress={onMute}
+      />
+
+      <Button
+        title="Unmute"
+        onPress={onUnmute}
+      />
+
+      <Button
+        title="Video On"
+        onPress={onVideoOn}
+      />
+
+      <Button
+        title="Video Off"
+        onPress={onVideoOff}
+      />
+
+      <Button
+        title="Share Screen"
+        onPress={
+          onShareScreen
+        }
+      />
+
+      <Button
+        title="End Call"
+        onPress={onEnd}
+      />
+    </View>
+  );
+}

package/src/screens/CallHistoryScreen.tsx

@@ -0,0 +1,41 @@
+import React from "react";
+
+import {
+    FlatList,
+    Text,
+    View,
+} from "react-native";
+
+export default function
+    CallHistoryScreen({
+        calls,
+    }: any) {
+
+    return (
+        <FlatList
+            data={calls}
+            keyExtractor={item =>
+                item.id
+            }
+            renderItem={({
+                item,
+            }) => (
+                <View>
+
+                    <Text>
+                        {item.customerName}
+                    </Text>
+
+                    <Text>
+                        {item.status}
+                    </Text>
+
+                    <Text>
+                        {item.createdAt}
+                    </Text>
+
+                </View>
+            )}
+        />
+    );
+}

package/src/screens/IncomingCallScreen.tsx

@@ -0,0 +1,51 @@
+import React from "react";
+
+import {
+  View,
+  Text,
+  Button,
+} from "react-native";
+
+export default function
+IncomingCallScreen({
+  call,
+  onAccept,
+  onReject,
+}: any) {
+
+  return (
+    <View
+      style={{
+        flex: 1,
+        justifyContent:
+          "center",
+      }}
+    >
+      <Text>
+        Incoming Call
+      </Text>
+
+      <Text>
+        {call?.customerName}
+      </Text>
+
+      <Button
+        title="Accept"
+        onPress={() =>
+          onAccept(
+            call.id
+          )
+        }
+      />
+
+      <Button
+        title="Reject"
+        onPress={() =>
+          onReject(
+            call.id
+          )
+        }
+      />
+    </View>
+  );
+}

package/src/screens/ScreenShareScreen.tsx

@@ -0,0 +1,28 @@
+import React from "react";
+
+import {
+  View,
+  Text,
+  Button,
+} from "react-native";
+
+export default function
+ScreenShareScreen({
+  onStop,
+}: any) {
+
+  return (
+    <View>
+
+      <Text>
+        Screen Sharing Active
+      </Text>
+
+      <Button
+        title="Stop Sharing"
+        onPress={onStop}
+      />
+
+    </View>
+  );
+}

package/src/services/CallingService.ts

@@ -0,0 +1,68 @@
+import axios from "axios";
+
+export class CallingService {
+  constructor(
+    private apiBaseUrl: string,
+    private jwtToken: string
+  ) {}
+
+  async createCall() {
+    const response = await axios.post(
+      `${this.apiBaseUrl}/api/v1/calls`,
+      {},
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+
+  async acceptCall(callId: string) {
+    const response = await axios.post(
+      `${this.apiBaseUrl}/api/v1/calls/${callId}/accept`,
+      {},
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+
+  async rejectCall(callId: string) {
+    const response = await axios.post(
+      `${this.apiBaseUrl}/api/v1/calls/${callId}/reject`,
+      {},
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+
+  async endCall(callId: string) {
+    const response = await axios.post(
+      `${this.apiBaseUrl}/api/v1/calls/${callId}/end`,
+      {},
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+}

package/src/services/NotificationService.ts

@@ -0,0 +1,58 @@
+import { socketManager } from "../sockets/socket";
+
+export class NotificationService {
+  listenIncomingCall(
+    callback: (payload: any) => void
+  ) {
+    socketManager
+      .getSocket()
+      ?.on(
+        "INCOMING_CALL",
+        callback
+      );
+  }
+
+  listenCallAccepted(
+    callback: (payload: any) => void
+  ) {
+    socketManager
+      .getSocket()
+      ?.on(
+        "CALL_ACCEPTED",
+        callback
+      );
+  }
+
+  listenCallRejected(
+    callback: (payload: any) => void
+  ) {
+    socketManager
+      .getSocket()
+      ?.on(
+        "CALL_REJECTED",
+        callback
+      );
+  }
+
+  listenCallTaken(
+    callback: (payload: any) => void
+  ) {
+    socketManager
+      .getSocket()
+      ?.on(
+        "CALL_TAKEN",
+        callback
+      );
+  }
+
+  listenCallEnded(
+    callback: (payload: any) => void
+  ) {
+    socketManager
+      .getSocket()
+      ?.on(
+        "CALL_ENDED",
+        callback
+      );
+  }
+}

package/src/services/PresenceService.ts

@@ -0,0 +1,58 @@
+import axios from "axios";
+
+export class PresenceService {
+  constructor(
+    private apiBaseUrl: string,
+    private jwtToken: string
+  ) {}
+
+  async heartbeat() {
+    const response = await axios.post(
+      `${this.apiBaseUrl}/api/v1/presence/heartbeat`,
+      {},
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+
+  async updateStatus(
+    status:
+      | "Available"
+      | "Busy"
+      | "Away"
+      | "Offline"
+  ) {
+    const response = await axios.put(
+      `${this.apiBaseUrl}/api/v1/presence/status`,
+      { status },
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+
+  async getAvailableAgents() {
+    const response = await axios.get(
+      `${this.apiBaseUrl}/api/v1/presence/agents`,
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+
+    return response.data;
+  }
+}

package/src/services/RecordingService.ts

@@ -0,0 +1,50 @@
+import axios from "axios";
+
+export class RecordingService {
+  constructor(
+    private apiBaseUrl: string,
+    private jwtToken: string
+  ) {}
+
+  async startRecording(
+    callId: string
+  ) {
+    return axios.post(
+      `${this.apiBaseUrl}/api/v1/recordings/start`,
+      { callId },
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+  }
+
+  async stopRecording(
+    recordingId: string
+  ) {
+    return axios.post(
+      `${this.apiBaseUrl}/api/v1/recordings/stop`,
+      { recordingId },
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+  }
+
+  async getHistory() {
+    return axios.get(
+      `${this.apiBaseUrl}/api/v1/recordings`,
+      {
+        headers: {
+          Authorization:
+            `Bearer ${this.jwtToken}`,
+        },
+      }
+    );
+  }
+}

package/src/services/RemoteControlService.ts

@@ -0,0 +1,64 @@
+export class RemoteControlService {
+
+  requestControl() {
+    console.log(
+      "CONTROL_REQUEST"
+    );
+  }
+
+  approveControl() {
+    console.log(
+      "CONTROL_APPROVED"
+    );
+  }
+
+  denyControl() {
+    console.log(
+      "CONTROL_DENIED"
+    );
+  }
+
+  endControl() {
+    console.log(
+      "CONTROL_ENDED"
+    );
+  }
+
+  pointerMove(
+    x: number,
+    y: number
+  ) {
+    console.log(
+      "POINTER_MOVE",
+      x,
+      y
+    );
+  }
+
+  click(
+    x: number,
+    y: number
+  ) {
+    console.log(
+      "CLICK",
+      x,
+      y
+    );
+  }
+
+  scroll(
+    delta: number
+  ) {
+    console.log(
+      "SCROLL",
+      delta
+    );
+  }
+
+  keyInput(text: string) {
+    console.log(
+      "KEY_INPUT",
+      text
+    );
+  }
+}

package/src/services/TokenService.ts

@@ -0,0 +1,47 @@
+import axios from "axios";
+
+import {
+  AcsConfig,
+  AcsTokenResponse,
+} from "../core/types";
+
+export class TokenService {
+
+  constructor(
+    private config: AcsConfig
+  ) {}
+
+  async generateToken() {
+
+    const response =
+      await axios.post(
+        `${this.config.apiBaseUrl}/api/v1/acs/token`,
+        {},
+        {
+          headers: {
+            Authorization:
+              `Bearer ${this.config.jwtToken}`,
+          },
+        }
+      );
+
+    return response.data
+      .data as AcsTokenResponse;
+  }
+
+  async checkTokenStatus() {
+
+    const response =
+      await axios.get(
+        `${this.config.apiBaseUrl}/api/v1/acs/token/status`,
+        {
+          headers: {
+            Authorization:
+              `Bearer ${this.config.jwtToken}`,
+          },
+        }
+      );
+
+    return response.data.data;
+  }
+}

package/src/sockets/socket.ts

@@ -0,0 +1,31 @@
+import { io, Socket } from "socket.io-client";
+
+class SocketManager {
+  private socket: Socket | null = null;
+
+  connect(url: string, jwtToken: string) {
+    if (this.socket?.connected) {
+      return this.socket;
+    }
+
+    this.socket = io(url, {
+      transports: ["websocket"],
+      auth: {
+        token: jwtToken,
+      },
+    });
+
+    return this.socket;
+  }
+
+  getSocket() {
+    return this.socket;
+  }
+
+  disconnect() {
+    this.socket?.disconnect();
+  }
+}
+
+export const socketManager =
+  new SocketManager();