ringcentral-softphone 1.3.2 → 1.3.4

package/dist/codec.cjs

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codec_exports = {};
+__export(codec_exports, {
+  default: () => codec_default
+});
+module.exports = __toCommonJS(codec_exports);
+var import_node_buffer = require("node:buffer");
+var import_opus = require("@evan/opus");
+class Codec {
+  id;
+  name;
+  packetSize;
+  timestampInterval;
+  createEncoder;
+  createDecoder;
+  constructor(name) {
+    this.name = name;
+    switch (name) {
+      case "OPUS/16000": {
+        this.createEncoder = () => {
+          const encoder = new import_opus.Encoder({ channels: 1, sample_rate: 16e3 });
+          return { encode: (pcm) => import_node_buffer.Buffer.from(encoder.encode(pcm)) };
+        };
+        this.createDecoder = () => {
+          const decoder = new import_opus.Decoder({ channels: 1, sample_rate: 16e3 });
+          return {
+            decode: (opus) => import_node_buffer.Buffer.from(decoder.decode(opus))
+          };
+        };
+        this.id = 109;
+        this.packetSize = 640;
+        this.timestampInterval = 320;
+        break;
+      }
+      case "OPUS/48000/2": {
+        this.createEncoder = () => {
+          const encoder = new import_opus.Encoder({ channels: 2, sample_rate: 48e3 });
+          return { encode: (pcm) => import_node_buffer.Buffer.from(encoder.encode(pcm)) };
+        };
+        this.createDecoder = () => {
+          const decoder = new import_opus.Decoder({ channels: 2, sample_rate: 48e3 });
+          return {
+            decode: (opus) => import_node_buffer.Buffer.from(decoder.decode(opus))
+          };
+        };
+        this.id = 111;
+        this.packetSize = 3840;
+        this.timestampInterval = 960;
+        break;
+      }
+      case "PCMU/8000": {
+        this.createEncoder = () => {
+          return { encode: (pcm) => pcm };
+        };
+        this.createDecoder = () => {
+          return { decode: (audio) => audio };
+        };
+        this.id = 0;
+        this.packetSize = 160;
+        this.timestampInterval = 160;
+        break;
+      }
+      default: {
+        throw new Error(`unsupported codec: ${name}`);
+      }
+    }
+  }
+}
+var codec_default = Codec;

package/dist/codec.js

@@ -0,0 +1,66 @@
+import { Buffer } from "node:buffer";
+import { Decoder, Encoder } from "@evan/opus";
+class Codec {
+  id;
+  name;
+  packetSize;
+  timestampInterval;
+  createEncoder;
+  createDecoder;
+  constructor(name) {
+    this.name = name;
+    switch (name) {
+      case "OPUS/16000": {
+        this.createEncoder = () => {
+          const encoder = new Encoder({ channels: 1, sample_rate: 16e3 });
+          return { encode: (pcm) => Buffer.from(encoder.encode(pcm)) };
+        };
+        this.createDecoder = () => {
+          const decoder = new Decoder({ channels: 1, sample_rate: 16e3 });
+          return {
+            decode: (opus) => Buffer.from(decoder.decode(opus))
+          };
+        };
+        this.id = 109;
+        this.packetSize = 640;
+        this.timestampInterval = 320;
+        break;
+      }
+      case "OPUS/48000/2": {
+        this.createEncoder = () => {
+          const encoder = new Encoder({ channels: 2, sample_rate: 48e3 });
+          return { encode: (pcm) => Buffer.from(encoder.encode(pcm)) };
+        };
+        this.createDecoder = () => {
+          const decoder = new Decoder({ channels: 2, sample_rate: 48e3 });
+          return {
+            decode: (opus) => Buffer.from(decoder.decode(opus))
+          };
+        };
+        this.id = 111;
+        this.packetSize = 3840;
+        this.timestampInterval = 960;
+        break;
+      }
+      case "PCMU/8000": {
+        this.createEncoder = () => {
+          return { encode: (pcm) => pcm };
+        };
+        this.createDecoder = () => {
+          return { decode: (audio) => audio };
+        };
+        this.id = 0;
+        this.packetSize = 160;
+        this.timestampInterval = 160;
+        break;
+      }
+      default: {
+        throw new Error(`unsupported codec: ${name}`);
+      }
+    }
+  }
+}
+var codec_default = Codec;
+export {
+  codec_default as default
+};

package/dist/dtmf.cjs

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dtmf_exports = {};
+__export(dtmf_exports, {
+  default: () => dtmf_default
+});
+module.exports = __toCommonJS(dtmf_exports);
+var import_node_buffer = require("node:buffer");
+const phoneChars = [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "*",
+  "#"
+];
+const payloads = [
+  393216,
+  393376,
+  393536,
+  8782624,
+  8782624,
+  8782624
+];
+const DTMF = {
+  phoneChars,
+  charToPayloads(char) {
+    const index = phoneChars.indexOf(char[0]);
+    if (index === -1) {
+      throw new Error("invalid phone char");
+    }
+    return payloads.map((payload) => {
+      const temp = payload + index * 16777216;
+      const buffer = import_node_buffer.Buffer.alloc(4);
+      buffer.writeIntBE(temp, 0, 4);
+      return buffer;
+    });
+  },
+  payloadToChar(payload) {
+    const intBE = payload.readIntBE(0, 4);
+    const index = (intBE - 393216) / 16777216;
+    return phoneChars[index];
+  }
+};
+var dtmf_default = DTMF;

package/dist/dtmf.d.ts

@@ -0,0 +1,7 @@
+import { Buffer } from "node:buffer";
+declare const DTMF: {
+    phoneChars: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "#"];
+    charToPayloads(char: string): Buffer<ArrayBuffer>[];
+    payloadToChar(payload: Buffer): "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "*" | "#";
+};
+export default DTMF;

package/dist/dtmf.js

@@ -0,0 +1,47 @@
+import { Buffer } from "node:buffer";
+const phoneChars = [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "*",
+  "#"
+];
+const payloads = [
+  393216,
+  393376,
+  393536,
+  8782624,
+  8782624,
+  8782624
+];
+const DTMF = {
+  phoneChars,
+  charToPayloads(char) {
+    const index = phoneChars.indexOf(char[0]);
+    if (index === -1) {
+      throw new Error("invalid phone char");
+    }
+    return payloads.map((payload) => {
+      const temp = payload + index * 16777216;
+      const buffer = Buffer.alloc(4);
+      buffer.writeIntBE(temp, 0, 4);
+      return buffer;
+    });
+  },
+  payloadToChar(payload) {
+    const intBE = payload.readIntBE(0, 4);
+    const index = (intBE - 393216) / 16777216;
+    return phoneChars[index];
+  }
+};
+var dtmf_default = DTMF;
+export {
+  dtmf_default as default
+};

package/dist/index.cjs

@@ -0,0 +1,260 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_events = __toESM(require("node:events"), 1);
+var import_node_tls = __toESM(require("node:tls"), 1);
+var import_wait_for_async = __toESM(require("wait-for-async"), 1);
+var import_inbound = __toESM(require("./call-session/inbound.js"), 1);
+var import_outbound = __toESM(require("./call-session/outbound.js"), 1);
+var import_codec = __toESM(require("./codec.js"), 1);
+var import_sip_message = require("./sip-message/index.js");
+var import_utils = require("./utils.js");
+class Softphone extends import_node_events.default {
+  sipInfo;
+  client;
+  codec;
+  fakeDomain = `${(0, import_utils.uuid)()}.invalid`;
+  fakeEmail = `${(0, import_utils.uuid)()}@${this.fakeDomain}`;
+  intervalHandle;
+  connected = false;
+  constructor(sipInfo) {
+    super();
+    if (sipInfo.codec === void 0) {
+      sipInfo.codec = "OPUS/16000";
+    }
+    this.codec = new import_codec.default(sipInfo.codec);
+    this.sipInfo = sipInfo;
+    if (this.sipInfo.domain === void 0) {
+      this.sipInfo.domain = "sip.ringcentral.com";
+    }
+    if (this.sipInfo.outboundProxy === void 0) {
+      this.sipInfo.outboundProxy = "sip10.ringcentral.com:5096";
+    }
+    const tokens = this.sipInfo.outboundProxy.split(":");
+    this.client = import_node_tls.default.connect(
+      {
+        host: tokens[0],
+        port: parseInt(tokens[1], 10),
+        rejectUnauthorized: !this.sipInfo.ignoreTlsCertErrors
+      },
+      () => {
+        this.connected = true;
+      }
+    );
+    let cache = "";
+    this.client.on("data", (data) => {
+      cache += data.toString("utf-8");
+      if (!cache.endsWith("\r\n")) {
+        return;
+      }
+      const tempMessages = cache.split("\r\nContent-Length: 0\r\n\r\n").filter((message) => message.trim() !== "");
+      cache = "";
+      for (let i = 0; i < tempMessages.length; i++) {
+        if (!tempMessages[i].includes("Content-Length: ")) {
+          tempMessages[i] = `${tempMessages[i]}\r
+Content-Length: 0`;
+        }
+      }
+      for (const message of tempMessages) {
+        this.emit("message", import_sip_message.InboundMessage.fromString(message));
+      }
+    });
+  }
+  instanceId = (0, import_utils.uuid)();
+  registerCallId = (0, import_utils.uuid)();
+  async register() {
+    if (!this.connected) {
+      await (0, import_wait_for_async.default)({
+        interval: 100,
+        times: 100,
+        condition: () => this.connected
+      });
+      if (!this.connected) {
+        throw new Error("Failed to register: connect to TLS timeout");
+      }
+    }
+    const sipRegister = async () => {
+      const fromTag = (0, import_utils.uuid)();
+      const requestMessage = new import_sip_message.RequestMessage(
+        `REGISTER sip:${this.sipInfo.domain} SIP/2.0`,
+        {
+          Via: `SIP/2.0/TLS ${this.client.localAddress}:${this.client.localPort};rport;branch=${(0, import_utils.branch)()};alias`,
+          "Max-Forwards": "70",
+          From: `<sip:${this.sipInfo.username}@${this.sipInfo.domain}>;tag=${fromTag}`,
+          To: `<sip:${this.sipInfo.username}@${this.sipInfo.domain}>`,
+          "Call-ID": this.registerCallId,
+          Contact: `<sip:${this.sipInfo.username}@${this.client.localAddress}:${this.client.localPort};transport=TLS;ob>;reg-id=1;+sip.instance="<urn:uuid:${this.instanceId}>"`,
+          Expires: 3600,
+          Allow: "PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS"
+        }
+      );
+      const inboundMessage = await this.send(requestMessage, true);
+      if (inboundMessage.subject.startsWith("SIP/2.0 200 ")) {
+        return;
+      }
+      const wwwAuth = inboundMessage.getHeader("Www-Authenticate");
+      const nonce = wwwAuth.match(/, nonce="(.+?)"/)[1];
+      const newMessage = requestMessage.fork();
+      newMessage.headers.Authorization = (0, import_utils.generateAuthorization)(
+        this.sipInfo,
+        nonce,
+        "REGISTER"
+      );
+      const message = await this.send(newMessage, true);
+      if (!message.subject.startsWith("SIP/2.0 200 ")) {
+        throw new Error(`Failed to register: ${message.subject}`);
+      }
+    };
+    await sipRegister();
+    this.intervalHandle = setInterval(
+      () => {
+        sipRegister().catch((error) => {
+          this.emit("registrationError", error);
+        });
+      },
+      30 * 1e3
+      // refresh registration every 30 seconds
+    );
+    this.on("message", (inboundMessage) => {
+      if (!inboundMessage.subject.startsWith("INVITE sip:")) {
+        return;
+      }
+      const outboundMessage = new import_sip_message.OutboundMessage("SIP/2.0 100 Trying", {
+        Via: inboundMessage.headers.Via,
+        "Call-ID": inboundMessage.getHeader("Call-ID"),
+        From: inboundMessage.headers.From,
+        To: inboundMessage.headers.To,
+        CSeq: inboundMessage.headers.CSeq,
+        "Content-Length": "0"
+      });
+      this.send(outboundMessage);
+      this.emit("invite", inboundMessage);
+    });
+  }
+  enableDebugMode() {
+    this.on(
+      "message",
+      (message) => console.log(`Receiving...(${/* @__PURE__ */ new Date()})
+${message.toString()}`)
+    );
+    const tlsWrite = this.client.write.bind(this.client);
+    this.client.write = (message) => {
+      console.log(`Sending...(${/* @__PURE__ */ new Date()})
+${message}`);
+      return tlsWrite(message);
+    };
+  }
+  revoke() {
+    clearInterval(this.intervalHandle);
+    this.removeAllListeners();
+    this.client.removeAllListeners();
+    this.client.destroy();
+  }
+  send(message, waitForReply = false) {
+    this.client.write(message.toString());
+    if (!waitForReply) {
+      return new Promise((resolve) => {
+        resolve(void 0);
+      });
+    }
+    return new Promise((resolve) => {
+      const messageListerner = (inboundMessage) => {
+        if (inboundMessage.headers.CSeq.trim().split(/\s+/)[0] !== message.headers.CSeq.trim().split(/\s+/)[0]) {
+          return;
+        }
+        if (inboundMessage.subject.startsWith("SIP/2.0 100 ")) {
+          return;
+        }
+        this.off("message", messageListerner);
+        resolve(inboundMessage);
+      };
+      this.on("message", messageListerner);
+    });
+  }
+  async answer(inviteMessage) {
+    const inboundCallSession = new import_inbound.default(this, inviteMessage);
+    await inboundCallSession.answer();
+    return inboundCallSession;
+  }
+  // decline an inbound call
+  async decline(inviteMessage) {
+    const newMessage = new import_sip_message.ResponseMessage(inviteMessage, 603);
+    await this.send(newMessage);
+  }
+  async call(callee) {
+    const offerSDP = `
+v=0
+o=- ${Date.now()} 0 IN IP4 ${this.client.localAddress}
+s=rc-softphone-ts
+c=IN IP4 ${this.client.localAddress}
+t=0 0
+m=audio ${(0, import_utils.randomInt)()} RTP/SAVP ${this.codec.id} 101
+a=rtpmap:${this.codec.id} ${this.codec.name}
+a=rtpmap:101 telephone-event/8000
+a=fmtp:101 0-15
+a=sendrecv
+a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:${import_utils.localKey}
+  `.trim();
+    const inviteMessage = new import_sip_message.RequestMessage(
+      `INVITE sip:${callee}@${this.sipInfo.domain} SIP/2.0`,
+      {
+        Via: `SIP/2.0/TLS ${this.client.localAddress}:${this.client.localPort};rport;branch=${(0, import_utils.branch)()};alias`,
+        "Max-Forwards": 70,
+        From: `<sip:${this.sipInfo.username}@${this.sipInfo.domain}>;tag=${(0, import_utils.uuid)()}`,
+        To: `<sip:${callee}@sip.ringcentral.com>`,
+        Contact: ` <sip:${this.sipInfo.username}@${this.client.localAddress}:${this.client.localPort};transport=TLS;ob>`,
+        "Call-ID": (0, import_utils.uuid)(),
+        Route: `<sip:${this.sipInfo.outboundProxy};transport=tls;lr>`,
+        Allow: `PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS`,
+        Supported: `replaces, 100rel, timer, norefersub`,
+        "Session-Expires": 1800,
+        "Min-SE": 90,
+        "Content-Type": "application/sdp"
+      },
+      offerSDP
+    );
+    const inboundMessage = await this.send(inviteMessage, true);
+    const proxyAuthenticate = inboundMessage.getHeader("Proxy-Authenticate");
+    const nonce = proxyAuthenticate.match(/, nonce="(.+?)"/)[1];
+    const newMessage = inviteMessage.fork();
+    newMessage.headers["Proxy-Authorization"] = (0, import_utils.generateAuthorization)(
+      this.sipInfo,
+      nonce,
+      "INVITE"
+    );
+    const progressMessage = await this.send(newMessage, true);
+    const outboundCallSession = new import_outbound.default(this, progressMessage);
+    outboundCallSession.sdp = offerSDP;
+    return outboundCallSession;
+  }
+}
+var index_default = Softphone;

package/dist/{cjs/index.d.ts → index.d.ts}

@@ -1,10 +1,10 @@
 import EventEmitter from "node:events";
-import { TLSSocket } from "node:tls";
+import { type TLSSocket } from "node:tls";
 import InboundCallSession from "./call-session/inbound.js";
 import OutboundCallSession from "./call-session/outbound.js";
-import { InboundMessage, OutboundMessage } from "./sip-message/index.js";
-import { SoftPhoneOptions } from "./types.js";
 import Codec from "./codec.js";
+import { InboundMessage, OutboundMessage } from "./sip-message/index.js";
+import type { SoftPhoneOptions } from "./types.js";
 declare class Softphone extends EventEmitter {
     sipInfo: SoftPhoneOptions;
     client: TLSSocket;