@dora-cell/sdk 0.1.1-beta.10

package/dist/index.js

@@ -0,0 +1,704 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var JsSIP = require('jssip');
+var EventEmitter = require('eventemitter3');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var JsSIP__default = /*#__PURE__*/_interopDefault(JsSIP);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// src/core/DoraCell.ts
+
+// src/types/index.ts
+var DoraCellError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "DoraCellError";
+  }
+};
+var AuthenticationError = class extends DoraCellError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", details);
+    this.name = "AuthenticationError";
+  }
+};
+var CallError = class extends DoraCellError {
+  constructor(message, details) {
+    super(message, "CALL_ERROR", details);
+    this.name = "CallError";
+  }
+};
+var ConnectionError = class extends DoraCellError {
+  constructor(message, details) {
+    super(message, "CONNECTION_ERROR", details);
+    this.name = "ConnectionError";
+  }
+};
+
+// src/core/AuthProvider.ts
+var ApiTokenAuthProvider = class {
+  constructor(apiToken, apiBaseUrl) {
+    this.credentials = null;
+    this.apiToken = apiToken;
+    let defaultBaseUrl = "";
+    if (typeof process !== "undefined" && process.env) {
+      defaultBaseUrl = process.env.NEXT_PUBLIC_BASE_API_URL || "";
+    }
+    this.apiBaseUrl = apiBaseUrl || defaultBaseUrl;
+  }
+  async authenticate(config) {
+    if (config.type !== "api-token") {
+      throw new AuthenticationError("Invalid auth config type for ApiTokenAuthProvider");
+    }
+    try {
+      const response = await fetch(`${this.apiBaseUrl}/api/sip-credentials`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${this.apiToken}`,
+          "Content-Type": "application/json",
+          "Accept": "application/json"
+        },
+        credentials: "include"
+      });
+      if (!response.ok) {
+        if (response.status === 401 || response.status === 403) {
+          throw new AuthenticationError(
+            "Invalid API token or insufficient permissions",
+            { status: response.status }
+          );
+        }
+        throw new AuthenticationError(
+          `Failed to fetch SIP credentials: ${response.status}`,
+          { status: response.status }
+        );
+      }
+      const data = await response.json();
+      this.credentials = this.parseCredentials(data);
+      return this.credentials;
+    } catch (error) {
+      if (error instanceof AuthenticationError) {
+        throw error;
+      }
+      throw new AuthenticationError(
+        `Authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { originalError: error }
+      );
+    }
+  }
+  async refreshCredentials() {
+    return this.authenticate({ type: "api-token", apiToken: this.apiToken });
+  }
+  isAuthenticated() {
+    return this.credentials !== null;
+  }
+  parseCredentials(data) {
+    const wsUrl = data.ws_url || data.wsUrl;
+    const sipUri = data.sip_uri || data.sipUri;
+    const password = data.password;
+    const sipDomain = data.sip_domain || data.sipDomain;
+    const extensions = data.extensions;
+    const expiresIn = data.expires_in || data.expiresIn;
+    if (!wsUrl || !sipUri) {
+      throw new AuthenticationError(
+        "Invalid credentials response: missing ws_url or sip_uri"
+      );
+    }
+    return {
+      wsUrl,
+      sipUri,
+      password: password || "",
+      sipDomain,
+      extensions,
+      expiresIn
+    };
+  }
+};
+var DirectCredentialsAuthProvider = class {
+  constructor() {
+    this.credentials = null;
+  }
+  async authenticate(config) {
+    if (config.type !== "direct") {
+      throw new AuthenticationError("Invalid auth config type for DirectCredentialsAuthProvider");
+    }
+    this.credentials = {
+      wsUrl: config.wsUrl,
+      sipUri: config.sipUri,
+      password: config.password
+    };
+    return this.credentials;
+  }
+  isAuthenticated() {
+    return this.credentials !== null;
+  }
+};
+var DEFAULT_WSS_URL = "wss://cell.usedora.com:8089";
+var DEFAULT_SIP_IP = "64.227.10.164";
+var DEFAULT_PASSWORD = "1234";
+var ExtensionAuthProvider = class {
+  constructor() {
+    this.credentials = null;
+  }
+  async authenticate(config) {
+    if (config.type !== "extension") {
+      throw new AuthenticationError("Invalid auth config type for ExtensionAuthProvider");
+    }
+    const extension = config.extension;
+    const password = config.password || DEFAULT_PASSWORD;
+    const wsUrl = DEFAULT_WSS_URL;
+    const sipDomain = config.sipDomain || DEFAULT_SIP_IP;
+    const sipUri = `sip:${extension}@${sipDomain}`;
+    this.credentials = {
+      wsUrl,
+      sipUri,
+      password,
+      sipDomain,
+      extensions: [{ extension, displayName: `Ext ${extension}`, isPrimary: true }]
+    };
+    return this.credentials;
+  }
+  isAuthenticated() {
+    return this.credentials !== null;
+  }
+};
+function createAuthProvider(config) {
+  switch (config.type) {
+    case "api-token":
+      return new ApiTokenAuthProvider(config.apiToken, config.apiBaseUrl);
+    case "direct":
+      return new DirectCredentialsAuthProvider();
+    case "extension":
+      return new ExtensionAuthProvider();
+    default:
+      throw new AuthenticationError("Unknown authentication type");
+  }
+}
+
+// src/utils/phoneFormatter.ts
+function formatPhoneToSIP(phone, sipDomain) {
+  let cleaned = phone.replace(/\D/g, "");
+  if (cleaned.length <= 4) {
+    return `sip:${cleaned}@${sipDomain}`;
+  }
+  if (cleaned.startsWith("0")) {
+    cleaned = "234" + cleaned.substring(1);
+    return `sip:${cleaned}@${sipDomain}`;
+  }
+  if (cleaned.startsWith("234")) {
+    return `sip:${cleaned}@${sipDomain}`;
+  }
+  cleaned = "234" + cleaned;
+  return `sip:${cleaned}@${sipDomain}`;
+}
+function normalizePhoneNumber(phone, countryCode = "234") {
+  let cleaned = phone.replace(/\D/g, "");
+  if (cleaned.length <= 4) {
+    return cleaned;
+  }
+  if (cleaned.startsWith("0")) {
+    return countryCode + cleaned.substring(1);
+  }
+  if (cleaned.startsWith(countryCode)) {
+    return cleaned;
+  }
+  return countryCode + cleaned;
+}
+function extractNumberFromSipUri(sipUri) {
+  const match = sipUri.match(/sip:([^@]+)@/);
+  return match ? match[1] : sipUri;
+}
+function isValidPhoneNumber(phone, minLength = 3) {
+  const cleaned = phone.replace(/\D/g, "");
+  return cleaned.length >= minLength;
+}
+
+// src/core/CallManager.ts
+var CallSession = class {
+  constructor(session, direction, remoteNumber, localExtension, events) {
+    this.status = "idle";
+    this.duration = 0;
+    // JsSIP RTCSession
+    this._isMuted = false;
+    this.remoteStreamValue = null;
+    this.id = this.generateCallId();
+    this.session = session;
+    this.direction = direction;
+    this.remoteNumber = remoteNumber;
+    this.localExtension = localExtension;
+    this.events = events;
+    this.setupSessionHandlers();
+  }
+  generateCallId() {
+    return `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  setupSessionHandlers() {
+    this.session.on("progress", (evt) => {
+      const code = evt.response?.status_code;
+      if (code === 180 || code === 183) {
+        this.status = "ringing";
+        this.events.emit("call:ringing", this);
+      }
+    });
+    this.session.on("confirmed", () => {
+      this.status = "ongoing";
+      this.startTime = Date.now();
+      this.startDurationTimer();
+      this.events.emit("call:connected", this);
+    });
+    this.session.on("peerconnection", (evt) => {
+      evt.peerconnection.ontrack = (event) => {
+        if (event.streams && event.streams[0]) {
+          this.remoteStreamValue = event.streams[0];
+        }
+      };
+    });
+    this.session.on("ended", (evt) => {
+      this.handleCallEnd(evt?.cause);
+    });
+    this.session.on("failed", (evt) => {
+      this.handleCallEnd(evt?.cause || "Call failed");
+    });
+    this.session.on("rejected", (evt) => {
+      this.handleCallEnd(evt?.cause || "Call rejected");
+    });
+  }
+  handleCallEnd(reason) {
+    this.status = "ended";
+    this.endTime = Date.now();
+    this.stopDurationTimer();
+    this.remoteStreamValue = null;
+    this._isMuted = false;
+    this.events.emit("call:ended", this, reason);
+  }
+  startDurationTimer() {
+    this.durationInterval = window.setInterval(() => {
+      if (this.startTime) {
+        this.duration = Math.floor((Date.now() - this.startTime) / 1e3);
+      }
+    }, 1e3);
+  }
+  stopDurationTimer() {
+    if (this.durationInterval) {
+      clearInterval(this.durationInterval);
+      this.durationInterval = void 0;
+    }
+  }
+  // Public methods
+  mute() {
+    if (this.session && !this._isMuted) {
+      this.session.mute({ audio: true });
+      this._isMuted = true;
+    }
+  }
+  unmute() {
+    if (this.session && this._isMuted) {
+      this.session.unmute({ audio: true });
+      this._isMuted = false;
+    }
+  }
+  hangup() {
+    if (this.session) {
+      this.session.terminate();
+    }
+  }
+  isMuted() {
+    return this._isMuted;
+  }
+  getRemoteStream() {
+    return this.remoteStreamValue;
+  }
+  getFormattedDuration() {
+    const mm = String(Math.floor(this.duration / 60)).padStart(2, "0");
+    const ss = String(this.duration % 60).padStart(2, "0");
+    return `${mm}:${ss}`;
+  }
+  destroy() {
+    this.stopDurationTimer();
+    this.session = null;
+    this.remoteStreamValue = null;
+  }
+};
+var CallManager = class {
+  constructor(credentials, events, callConfig) {
+    this.ua = null;
+    // JsSIP User Agent
+    this.currentCall = null;
+    this.credentials = credentials;
+    this.events = events;
+    this.callConfig = callConfig;
+  }
+  setUserAgent(ua) {
+    this.ua = ua;
+  }
+  /**
+   * Initiate an outbound call
+   */
+  async initiateCall(targetNumber, options) {
+    if (!this.ua) {
+      throw new CallError("User Agent not initialized");
+    }
+    if (this.currentCall && this.currentCall.status !== "ended") {
+      throw new CallError("A call is already in progress");
+    }
+    try {
+      await navigator.mediaDevices.getUserMedia({ audio: true });
+      const extension = options?.extension || this.getDefaultExtension();
+      const sipDomain = this.extractDomain(this.credentials.sipUri);
+      const sipTarget = formatPhoneToSIP(targetNumber, sipDomain);
+      const session = this.ua.call(sipTarget, {
+        mediaConstraints: options?.mediaConstraints || { audio: true },
+        pcConfig: this.callConfig.pcConfig
+      });
+      const call = new CallSession(
+        session,
+        "outbound",
+        targetNumber,
+        extension,
+        this.events
+      );
+      call.status = "connecting";
+      this.currentCall = call;
+      this.events.emit("call:outgoing", call);
+      return call;
+    } catch (error) {
+      throw new CallError(
+        `Failed to initiate call: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Answer an incoming call
+   */
+  answerCall(session) {
+    if (!session) {
+      throw new CallError("No session provided");
+    }
+    try {
+      const remoteUri = session.remote_identity?.uri?.toString() || "Unknown";
+      const extension = this.getDefaultExtension();
+      session.answer({
+        mediaConstraints: { audio: true },
+        pcConfig: this.callConfig.pcConfig
+      });
+      const call = new CallSession(
+        session,
+        "inbound",
+        remoteUri,
+        extension,
+        this.events
+      );
+      this.currentCall = call;
+      return call;
+    } catch (error) {
+      throw new CallError(
+        `Failed to answer call: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Handle incoming call from JsSIP
+   */
+  handleIncomingCall(session) {
+    const remoteUri = session.remote_identity?.uri?.toString() || "Unknown";
+    const extension = this.getDefaultExtension();
+    const call = new CallSession(
+      session,
+      "inbound",
+      remoteUri,
+      extension,
+      this.events
+    );
+    call.status = "ringing";
+    this.currentCall = call;
+    this.events.emit("call:incoming", call);
+    return call;
+  }
+  getCurrentCall() {
+    return this.currentCall;
+  }
+  clearCurrentCall() {
+    if (this.currentCall) {
+      this.currentCall.destroy();
+      this.currentCall = null;
+    }
+  }
+  getDefaultExtension() {
+    if (this.credentials.extensions && this.credentials.extensions.length > 0) {
+      return this.credentials.extensions[0].extension;
+    }
+    return this.extractExtension(this.credentials.sipUri);
+  }
+  extractExtension(sipUri) {
+    const match = sipUri.match(/sip:([^@]+)@/);
+    return match ? match[1] : "unknown";
+  }
+  extractDomain(sipUri) {
+    const match = sipUri.match(/@(.+)$/);
+    return match ? match[1] : "";
+  }
+  destroy() {
+    this.clearCurrentCall();
+    this.ua = null;
+  }
+};
+
+// src/core/DoraCell.ts
+var DoraCell = class {
+  constructor(config) {
+    this.credentials = null;
+    this.ua = null;
+    // JsSIP User Agent
+    this.callManager = null;
+    this.connectionStatus = "disconnected";
+    this.retryCount = 0;
+    this.maxRetries = 3;
+    this.config = {
+      autoSelectExtension: true,
+      debug: false,
+      ...config
+    };
+    this.events = new EventEmitter__default.default();
+    this.authProvider = createAuthProvider(config.auth);
+    if (this.config.debug) {
+      JsSIP__default.default.debug.enable("JsSIP:*");
+    }
+  }
+  /**
+   * Initialize the SDK - authenticate and connect to SIP server
+   */
+  async initialize() {
+    try {
+      this.credentials = await this.authProvider.authenticate(this.config.auth);
+      await this.initializeUserAgent();
+      this.initializeCallManager();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.emitError(new ConnectionError(`Initialization failed: ${errorMessage}`));
+      throw error;
+    }
+  }
+  async initializeUserAgent() {
+    if (!this.credentials) {
+      throw new ConnectionError("No credentials available");
+    }
+    try {
+      const socket = new JsSIP__default.default.WebSocketInterface(this.credentials.wsUrl);
+      const pcConfig = {
+        iceServers: this.config.turnServers || this.getDefaultTurnServers()
+      };
+      const uaConfig = {
+        uri: this.credentials.sipUri,
+        password: this.credentials.password,
+        sockets: [socket],
+        register: true,
+        display_name: this.getDisplayName(),
+        session_timers: false,
+        use_preloaded_route: false,
+        pcConfig,
+        instance_id: this.generateInstanceId()
+      };
+      this.ua = new JsSIP__default.default.UA(uaConfig);
+      this.setupUserAgentHandlers();
+      this.ua.start();
+    } catch (error) {
+      throw new ConnectionError(
+        `Failed to initialize User Agent: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  setupUserAgentHandlers() {
+    if (!this.ua) return;
+    this.ua.on("connected", () => {
+      this.connectionStatus = "connected";
+      this.emitConnectionStatus();
+    });
+    this.ua.on("disconnected", () => {
+      this.connectionStatus = "disconnected";
+      this.emitConnectionStatus();
+    });
+    this.ua.on("registered", () => {
+      this.connectionStatus = "registered";
+      this.retryCount = 0;
+      this.emitConnectionStatus();
+    });
+    this.ua.on("registrationFailed", (e) => {
+      this.connectionStatus = "registrationFailed";
+      this.emitConnectionStatus(e.cause);
+      if (this.retryCount < this.maxRetries) {
+        this.retryCount++;
+        setTimeout(() => {
+          this.ua?.register();
+        }, 3e3);
+      }
+    });
+    this.ua.on("newRTCSession", (e) => {
+      const session = e.session;
+      if (session.direction === "incoming") {
+        this.callManager?.handleIncomingCall(session);
+      }
+    });
+  }
+  initializeCallManager() {
+    if (!this.credentials) {
+      throw new ConnectionError("No credentials available for call manager");
+    }
+    const pcConfig = {
+      iceServers: this.config.turnServers || this.getDefaultTurnServers()
+    };
+    this.callManager = new CallManager(
+      this.credentials,
+      this.events,
+      { pcConfig }
+    );
+    this.callManager.setUserAgent(this.ua);
+  }
+  /**
+   * Make an outbound call
+   */
+  async call(phoneNumber, options) {
+    if (!this.callManager) {
+      throw new CallError("SDK not initialized. Call initialize() first.");
+    }
+    if (this.connectionStatus !== "registered") {
+      throw new CallError("Not registered to SIP server");
+    }
+    return this.callManager.initiateCall(phoneNumber, options);
+  }
+  /**
+   * Answer an incoming call
+   */
+  answerCall() {
+    const currentCall = this.callManager?.getCurrentCall();
+    if (!currentCall) {
+      throw new CallError("No incoming call to answer");
+    }
+    if (currentCall.direction !== "inbound") {
+      throw new CallError("Current call is not an incoming call");
+    }
+  }
+  /**
+   * Hangup the current call
+   */
+  hangup() {
+    const currentCall = this.callManager?.getCurrentCall();
+    if (!currentCall) {
+      throw new CallError("No active call to hang up");
+    }
+    currentCall.hangup();
+  }
+  /**
+   * Get current call
+   */
+  getCurrentCall() {
+    return this.callManager?.getCurrentCall() || null;
+  }
+  /**
+   * Get connection status
+   */
+  getStatus() {
+    return this.connectionStatus;
+  }
+  /**
+   * Get available extensions
+   */
+  getExtensions() {
+    if (!this.credentials?.extensions) {
+      return [];
+    }
+    return this.credentials.extensions.map((ext) => ext.extension);
+  }
+  /**
+   * Event listener management
+   */
+  on(event, handler) {
+    this.events.on(event, handler);
+  }
+  off(event, handler) {
+    this.events.off(event, handler);
+  }
+  once(event, handler) {
+    this.events.once(event, handler);
+  }
+  /**
+   * Cleanup and destroy the SDK instance
+   */
+  destroy() {
+    if (this.ua) {
+      this.ua.stop();
+      this.ua = null;
+    }
+    if (this.callManager) {
+      this.callManager.destroy();
+      this.callManager = null;
+    }
+    this.events.removeAllListeners();
+    this.connectionStatus = "disconnected";
+    this.credentials = null;
+  }
+  // Helper methods
+  emitConnectionStatus(error) {
+    const state = {
+      status: this.connectionStatus,
+      extension: this.credentials?.extensions?.[0]?.extension,
+      error
+    };
+    this.events.emit("connection:status", state);
+  }
+  emitError(error) {
+    this.events.emit("error", error);
+  }
+  getDefaultTurnServers() {
+    let turnUri = "turn:64.227.10.164:3478";
+    let turnUser = "02018890089";
+    let turnPass = "dora12345";
+    if (typeof process !== "undefined" && process.env) {
+      turnUri = process.env.NEXT_PUBLIC_TURN_URI || turnUri;
+      turnUser = process.env.NEXT_PUBLIC_TURN_USER || turnUser;
+      turnPass = process.env.NEXT_PUBLIC_TURN_PASS || turnPass;
+    }
+    return [
+      {
+        urls: turnUri,
+        username: turnUser,
+        credential: turnPass
+      }
+    ];
+  }
+  getDisplayName() {
+    if (this.credentials?.extensions?.[0]?.displayName) {
+      return this.credentials.extensions[0].displayName;
+    }
+    if (this.credentials?.extensions?.[0]?.extension) {
+      return `Ext ${this.credentials.extensions[0].extension}`;
+    }
+    return "Dora Cell User";
+  }
+  generateInstanceId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+};
+
+exports.AuthenticationError = AuthenticationError;
+exports.CallError = CallError;
+exports.CallSession = CallSession;
+exports.ConnectionError = ConnectionError;
+exports.DoraCell = DoraCell;
+exports.DoraCellError = DoraCellError;
+exports.default = DoraCell;
+exports.extractNumberFromSipUri = extractNumberFromSipUri;
+exports.formatPhoneToSIP = formatPhoneToSIP;
+exports.isValidPhoneNumber = isValidPhoneNumber;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map