stfca 1.0.0

package/src/api/socket/detail/buildStream.js

@@ -0,0 +1,208 @@
+"use strict";
+
+const { Writable, PassThrough } = require("stream");
+const Duplexify = require("duplexify");
+
+function buildProxy() {
+  let target = null;
+  let ended = false;
+  const Proxy = new Writable({
+    autoDestroy: true,
+    write(chunk, enc, cb) {
+      if (ended || this.destroyed) return cb();
+      const ws = target;
+      if (ws && ws.readyState === 1) {
+        try {
+          ws.send(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk), cb);
+        } catch (e) {
+          cb(e);
+        }
+      } else cb();
+    },
+    writev(chunks, cb) {
+      if (ended || this.destroyed) return cb();
+      const ws = target;
+      if (!ws || ws.readyState !== 1) return cb();
+      try {
+        for (const { chunk } of chunks) {
+          ws.send(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        cb();
+      } catch (e) {
+        cb(e);
+      }
+    },
+    final(cb) {
+      ended = true;
+      const ws = target;
+      target = null;
+      if (ws && (ws.readyState === 0 || ws.readyState === 1)) {
+        try {
+          typeof ws.terminate === "function" ? ws.terminate() : ws.close();
+        } catch { }
+      }
+      cb();
+    }
+  });
+  Proxy.setTarget = ws => {
+    if (ended) return;
+    target = ws;
+  };
+  Proxy.hardEnd = () => {
+    ended = true;
+    target = null;
+  };
+  return Proxy;
+}
+
+function buildStream(options, WebSocket, Proxy) {
+  const readable = new PassThrough();
+  const Stream = Duplexify(undefined, undefined, Object.assign({ end: false, autoDestroy: true }, options));
+  const NoopWritable = new Writable({ write(_c, _e, cb) { cb(); } });
+  let ws = WebSocket;
+  let pingTimer = null;
+  let livenessTimer = null;
+  let lastActivity = Date.now();
+  let attached = false;
+  let style = "prop";
+  let closed = false;
+
+  const toBuffer = d => {
+    if (Buffer.isBuffer(d)) return d;
+    if (d instanceof ArrayBuffer) return Buffer.from(d);
+    if (ArrayBuffer.isView(d)) return Buffer.from(d.buffer, d.byteOffset, d.byteLength);
+    return Buffer.from(String(d));
+  };
+
+  const swapToNoopWritable = () => {
+    try { Stream.setWritable(NoopWritable); } catch { }
+  };
+
+  const onOpen = () => {
+    if (closed) return;
+    Proxy.setTarget(ws);
+    Stream.setWritable(Proxy);
+    Stream.setReadable(readable);
+    Stream.emit("connect");
+    lastActivity = Date.now();
+    clearInterval(pingTimer);
+    clearInterval(livenessTimer);
+    pingTimer = setInterval(() => {
+      if (!ws || ws.readyState !== 1) return;
+      if (typeof ws.ping === "function") {
+        try { ws.ping(); } catch { }
+      } else {
+        try { ws.send("ping"); } catch { }
+      }
+    }, 30000);
+    livenessTimer = setInterval(() => {
+      if (!ws || ws.readyState !== 1) return;
+      if (Date.now() - lastActivity > 65000) {
+        try { typeof ws.terminate === "function" ? ws.terminate() : ws.close(); } catch { }
+      }
+    }, 10000);
+  };
+
+  const onMessage = data => {
+    lastActivity = Date.now();
+    readable.write(toBuffer(style === "dom" && data && data.data !== undefined ? data.data : data));
+  };
+
+  const onPong = () => {
+    lastActivity = Date.now();
+  };
+
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(pingTimer);
+    clearInterval(livenessTimer);
+    pingTimer = null;
+    livenessTimer = null;
+    Proxy.hardEnd();
+    swapToNoopWritable();
+    if (ws) {
+      detach(ws);
+      try {
+        if (ws.readyState === 1) {
+          typeof ws.terminate === "function" ? ws.terminate() : ws.close();
+        }
+      } catch { }
+      ws = null;
+    }
+    readable.end();
+  };
+
+  const onError = err => {
+    cleanup();
+    Stream.destroy(err);
+  };
+
+  const onClose = () => {
+    cleanup();
+    Stream.end();
+    if (!Stream.destroyed) Stream.destroy();
+  };
+
+  const attach = w => {
+    if (attached || !w) return;
+    attached = true;
+    if (typeof w.on === "function" && typeof w.off === "function") {
+      style = "node";
+      w.on("open", onOpen);
+      w.on("message", onMessage);
+      w.on("error", onError);
+      w.on("close", onClose);
+      if (typeof w.on === "function") w.on("pong", onPong);
+    } else if (typeof w.addEventListener === "function" && typeof w.removeEventListener === "function") {
+      style = "dom";
+      w.addEventListener("open", onOpen);
+      w.addEventListener("message", onMessage);
+      w.addEventListener("error", onError);
+      w.addEventListener("close", onClose);
+    } else {
+      style = "prop";
+      w.onopen = onOpen;
+      w.onmessage = onMessage;
+      w.onerror = onError;
+      w.onclose = onClose;
+    }
+  };
+
+  const detach = w => {
+    if (!attached || !w) return;
+    attached = false;
+    if (style === "node" && typeof w.off === "function") {
+      w.off("open", onOpen);
+      w.off("message", onMessage);
+      w.off("error", onError);
+      w.off("close", onClose);
+      if (typeof w.off === "function") w.off("pong", onPong);
+    } else if (style === "dom" && typeof w.removeEventListener === "function") {
+      w.removeEventListener("open", onOpen);
+      w.removeEventListener("message", onMessage);
+      w.removeEventListener("error", onError);
+      w.removeEventListener("close", onClose);
+    } else {
+      w.onopen = null;
+      w.onmessage = null;
+      w.onerror = null;
+      w.onclose = null;
+    }
+  };
+
+  attach(ws);
+  if (ws && ws.readyState === 1) onOpen();
+
+  Stream.on("prefinish", swapToNoopWritable);
+  Stream.on("finish", cleanup);
+  Stream.on("close", cleanup);
+  Proxy.on("close", swapToNoopWritable);
+
+  return Stream;
+}
+
+module.exports = {
+  buildProxy,
+  buildStream
+};

package/src/api/socket/detail/constants.js

@@ -0,0 +1,24 @@
+"use strict";
+module.exports = {
+  topics: [
+    "/ls_req",
+    "/ls_resp",
+    "/legacy_web",
+    "/webrtc",
+    "/rtc_multi",
+    "/onevc",
+    "/br_sr",
+    "/sr_res",
+    "/t_ms",
+    "/thread_typing",
+    "/orca_typing_notifications",
+    "/notify_disconnect",
+    "/orca_presence",
+    "/inbox",
+    "/mercury",
+    "/messaging_events",
+    "/orca_message_notifications",
+    "/pp",
+    "/webrtc_response"
+  ]
+};

package/src/api/socket/listenMqtt.js

@@ -0,0 +1,133 @@
+"use strict";
+const mqtt = require("mqtt");
+const WebSocket = require("ws");
+const HttpsProxyAgent = require("https-proxy-agent");
+const EventEmitter = require("events");
+const { parseAndCheckLogin } = require("../../utils/client");
+const { buildProxy, buildStream } = require("./detail/buildStream");
+const { topics } = require("./detail/constants");
+const createParseDelta = require("./core/parseDelta");
+const createListenMqtt = require("./core/connectMqtt");
+const createGetSeqID = require("./core/getSeqID");
+const markDelivery = require("./core/markDelivery");
+const getTaskResponseData = require("./core/getTaskResponseData");
+const parseDelta = createParseDelta({ markDelivery, parseAndCheckLogin });
+const listenMqtt = createListenMqtt({ WebSocket, mqtt, HttpsProxyAgent, buildStream, buildProxy, topics, parseDelta, getTaskResponseData });
+const getSeqIDFactory = createGetSeqID({ parseAndCheckLogin, listenMqtt });
+module.exports = function (defaultFuncs, api, ctx) {
+  const identity = function () { };
+  let globalCallback = identity;
+  function getSeqIDWrapper() {
+    const form = {
+      av: ctx.userID,
+      queries: JSON.stringify({
+        o0: { doc_id: "3336396659757871", query_params: { limit: 1, before: null, tags: ["INBOX"], includeDeliveryReceipts: false, includeSeqID: true } }
+      })
+    };
+    console.log("[FCA-INFO] MQTT getSeqID call");
+    return getSeqIDFactory(defaultFuncs, api, ctx, globalCallback, form).then(() => {
+      console.log("[FCA-INFO] MQTT getSeqID done");
+    }).catch(e => {
+      console.error(`[FCA-ERROR] MQTT getSeqID error: ${e && e.message ? e.message : e}`);
+    });
+  }
+  function isConnected() {
+    return !!(ctx.mqttClient && ctx.mqttClient.connected);
+  }
+  function unsubAll(cb) {
+    if (!isConnected()) return cb && cb();
+    let pending = topics.length;
+    if (!pending) return cb && cb();
+    let done = false;
+    topics.forEach(t => {
+      ctx.mqttClient.unsubscribe(t, err => {
+        const msg = String(err && err.message ? err.message : err || "");
+        if (msg && /No subscription existed/i.test(msg)) err = null;
+        if (--pending === 0 && !done) {
+          done = true;
+          cb && cb();
+        }
+      });
+    });
+  }
+  function endQuietly(next) {
+    const finish = () => {
+      ctx.mqttClient = undefined;
+      ctx.lastSeqId = null;
+      ctx.syncToken = undefined;
+      ctx.t_mqttCalled = false;
+      ctx._ending = false;
+      next && next();
+    };
+    try {
+      if (ctx.mqttClient) {
+        if (isConnected()) {
+          try { ctx.mqttClient.publish("/browser_close", "{}"); } catch (_) { }
+        }
+        ctx.mqttClient.end(true, finish);
+      } else finish();
+    } catch (_) {
+      finish();
+    }
+  }
+  function delayedReconnect() {
+    console.log("[FCA-INFO] MQTT reconnect in 2000ms");
+    setTimeout(() => getSeqIDWrapper(), 2000);
+  }
+  function forceCycle() {
+    ctx._ending = true;
+    console.warn("[FCA-WARN] MQTT force cycle begin");
+    unsubAll(() => {
+      endQuietly(() => {
+        delayedReconnect();
+      });
+    });
+  }
+  return function (callback) {
+    class MessageEmitter extends EventEmitter {
+      stopListening(callback2) {
+        const cb = callback2 || function () { };
+        console.log("[FCA-INFO] MQTT stop requested");
+        globalCallback = identity;
+        if (ctx._autoCycleTimer) {
+          clearInterval(ctx._autoCycleTimer);
+          ctx._autoCycleTimer = null;
+          console.log("[FCA-INFO] MQTT auto-cycle cleared");
+        }
+        ctx._ending = true;
+        unsubAll(() => {
+          endQuietly(() => {
+            console.log("[FCA-INFO] MQTT stopped");
+            cb();
+            delayedReconnect();
+          });
+        });
+      }
+      async stopListeningAsync() {
+        return new Promise(resolve => { this.stopListening(resolve); });
+      }
+    }
+    const msgEmitter = new MessageEmitter();
+    globalCallback = callback || function (error, message) {
+      if (error) { console.error("[FCA-ERROR] MQTT emit error"); return msgEmitter.emit("error", error); }
+      msgEmitter.emit("message", message);
+    };
+    if (!ctx.firstListen) ctx.lastSeqId = null;
+    ctx.syncToken = undefined;
+    ctx.t_mqttCalled = false;
+    if (ctx._autoCycleTimer) {
+      clearInterval(ctx._autoCycleTimer);
+      ctx._autoCycleTimer = null;
+    }
+    ctx._autoCycleTimer = setInterval(forceCycle, 60 * 60 * 1000);
+    console.log("[FCA-INFO] MQTT auto-cycle enabled 3600000ms");
+    if (!ctx.firstListen || !ctx.lastSeqId) getSeqIDWrapper();
+    else {
+      console.log("[FCA-INFO] MQTT starting listenMqtt");
+      listenMqtt(defaultFuncs, api, ctx, globalCallback);
+    }
+    api.stopListening = msgEmitter.stopListening;
+    api.stopListeningAsync = msgEmitter.stopListeningAsync;
+    return msgEmitter;
+  };
+};