@glodon-aiot/agent-cli-ui 2.4.7

package/dist/es/node_modules/socket.io-parser/build/esm/index.mjs

@@ -0,0 +1,203 @@
+import { Emitter as h } from "../../../@socket.io/component-emitter/lib/esm/index.mjs";
+import { deconstructPacket as f, reconstructPacket as N } from "./binary.mjs";
+import { hasBinary as E, isBinary as d } from "./is-binary.mjs";
+const A = [
+  "connect",
+  "connect_error",
+  "disconnect",
+  "disconnecting",
+  "newListener",
+  "removeListener"
+  // used by the Node.js EventEmitter
+], y = 5;
+var r;
+(function(n) {
+  n[n.CONNECT = 0] = "CONNECT", n[n.DISCONNECT = 1] = "DISCONNECT", n[n.EVENT = 2] = "EVENT", n[n.ACK = 3] = "ACK", n[n.CONNECT_ERROR = 4] = "CONNECT_ERROR", n[n.BINARY_EVENT = 5] = "BINARY_EVENT", n[n.BINARY_ACK = 6] = "BINARY_ACK";
+})(r || (r = {}));
+class g {
+  /**
+   * Encoder constructor
+   *
+   * @param {function} replacer - custom replacer to pass down to JSON.parse
+   */
+  constructor(t) {
+    this.replacer = t;
+  }
+  /**
+   * Encode a packet as a single string if non-binary, or as a
+   * buffer sequence, depending on packet type.
+   *
+   * @param {Object} obj - packet object
+   */
+  encode(t) {
+    return (t.type === r.EVENT || t.type === r.ACK) && E(t) ? this.encodeAsBinary({
+      type: t.type === r.EVENT ? r.BINARY_EVENT : r.BINARY_ACK,
+      nsp: t.nsp,
+      data: t.data,
+      id: t.id
+    }) : [this.encodeAsString(t)];
+  }
+  /**
+   * Encode packet as string.
+   */
+  encodeAsString(t) {
+    let e = "" + t.type;
+    return (t.type === r.BINARY_EVENT || t.type === r.BINARY_ACK) && (e += t.attachments + "-"), t.nsp && t.nsp !== "/" && (e += t.nsp + ","), t.id != null && (e += t.id), t.data != null && (e += JSON.stringify(t.data, this.replacer)), e;
+  }
+  /**
+   * Encode packet as 'buffer sequence' by removing blobs, and
+   * deconstructing packet into object with placeholders and
+   * a list of buffers.
+   */
+  encodeAsBinary(t) {
+    const e = f(t), s = this.encodeAsString(e.packet), o = e.buffers;
+    return o.unshift(s), o;
+  }
+}
+function a(n) {
+  return Object.prototype.toString.call(n) === "[object Object]";
+}
+class u extends h {
+  /**
+   * Decoder constructor
+   *
+   * @param {function} reviver - custom reviver to pass down to JSON.stringify
+   */
+  constructor(t) {
+    super(), this.reviver = t;
+  }
+  /**
+   * Decodes an encoded packet string into packet JSON.
+   *
+   * @param {String} obj - encoded packet
+   */
+  add(t) {
+    let e;
+    if (typeof t == "string") {
+      if (this.reconstructor)
+        throw new Error("got plaintext data when reconstructing a packet");
+      e = this.decodeString(t);
+      const s = e.type === r.BINARY_EVENT;
+      s || e.type === r.BINARY_ACK ? (e.type = s ? r.EVENT : r.ACK, this.reconstructor = new l(e), e.attachments === 0 && super.emitReserved("decoded", e)) : super.emitReserved("decoded", e);
+    } else if (d(t) || t.base64)
+      if (this.reconstructor)
+        e = this.reconstructor.takeBinaryData(t), e && (this.reconstructor = null, super.emitReserved("decoded", e));
+      else
+        throw new Error("got binary data when not reconstructing a packet");
+    else
+      throw new Error("Unknown type: " + t);
+  }
+  /**
+   * Decode a packet String (JSON data)
+   *
+   * @param {String} str
+   * @return {Object} packet
+   */
+  decodeString(t) {
+    let e = 0;
+    const s = {
+      type: Number(t.charAt(0))
+    };
+    if (r[s.type] === void 0)
+      throw new Error("unknown packet type " + s.type);
+    if (s.type === r.BINARY_EVENT || s.type === r.BINARY_ACK) {
+      const i = e + 1;
+      for (; t.charAt(++e) !== "-" && e != t.length; )
+        ;
+      const c = t.substring(i, e);
+      if (c != Number(c) || t.charAt(e) !== "-")
+        throw new Error("Illegal attachments");
+      s.attachments = Number(c);
+    }
+    if (t.charAt(e + 1) === "/") {
+      const i = e + 1;
+      for (; ++e && !(t.charAt(e) === "," || e === t.length); )
+        ;
+      s.nsp = t.substring(i, e);
+    } else
+      s.nsp = "/";
+    const o = t.charAt(e + 1);
+    if (o !== "" && Number(o) == o) {
+      const i = e + 1;
+      for (; ++e; ) {
+        const c = t.charAt(e);
+        if (c == null || Number(c) != c) {
+          --e;
+          break;
+        }
+        if (e === t.length)
+          break;
+      }
+      s.id = Number(t.substring(i, e + 1));
+    }
+    if (t.charAt(++e)) {
+      const i = this.tryParse(t.substr(e));
+      if (u.isPayloadValid(s.type, i))
+        s.data = i;
+      else
+        throw new Error("invalid payload");
+    }
+    return s;
+  }
+  tryParse(t) {
+    try {
+      return JSON.parse(t, this.reviver);
+    } catch (e) {
+      return !1;
+    }
+  }
+  static isPayloadValid(t, e) {
+    switch (t) {
+      case r.CONNECT:
+        return a(e);
+      case r.DISCONNECT:
+        return e === void 0;
+      case r.CONNECT_ERROR:
+        return typeof e == "string" || a(e);
+      case r.EVENT:
+      case r.BINARY_EVENT:
+        return Array.isArray(e) && (typeof e[0] == "number" || typeof e[0] == "string" && A.indexOf(e[0]) === -1);
+      case r.ACK:
+      case r.BINARY_ACK:
+        return Array.isArray(e);
+    }
+  }
+  /**
+   * Deallocates a parser's resources
+   */
+  destroy() {
+    this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+  }
+}
+class l {
+  constructor(t) {
+    this.packet = t, this.buffers = [], this.reconPack = t;
+  }
+  /**
+   * Method to be called when binary data received from connection
+   * after a BINARY_EVENT packet.
+   *
+   * @param {Buffer | ArrayBuffer} binData - the raw binary data received
+   * @return {null | Object} returns null if more binary data is expected or
+   *   a reconstructed packet object if all buffers have been received.
+   */
+  takeBinaryData(t) {
+    if (this.buffers.push(t), this.buffers.length === this.reconPack.attachments) {
+      const e = N(this.reconPack, this.buffers);
+      return this.finishedReconstruction(), e;
+    }
+    return null;
+  }
+  /**
+   * Cleans up binary packet reconstruction variables.
+   */
+  finishedReconstruction() {
+    this.reconPack = null, this.buffers = [];
+  }
+}
+export {
+  u as Decoder,
+  g as Encoder,
+  r as PacketType,
+  y as protocol
+};

package/dist/es/node_modules/socket.io-parser/build/esm/is-binary.mjs

@@ -0,0 +1,26 @@
+const i = typeof ArrayBuffer == "function", o = (t) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(t) : t.buffer instanceof ArrayBuffer, n = Object.prototype.toString, u = typeof Blob == "function" || typeof Blob != "undefined" && n.call(Blob) === "[object BlobConstructor]", c = typeof File == "function" || typeof File != "undefined" && n.call(File) === "[object FileConstructor]";
+function a(t) {
+  return i && (t instanceof ArrayBuffer || o(t)) || u && t instanceof Blob || c && t instanceof File;
+}
+function r(t, l) {
+  if (!t || typeof t != "object")
+    return !1;
+  if (Array.isArray(t)) {
+    for (let e = 0, f = t.length; e < f; e++)
+      if (r(t[e]))
+        return !0;
+    return !1;
+  }
+  if (a(t))
+    return !0;
+  if (t.toJSON && typeof t.toJSON == "function" && arguments.length === 1)
+    return r(t.toJSON(), !0);
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e) && r(t[e]))
+      return !0;
+  return !1;
+}
+export {
+  r as hasBinary,
+  a as isBinary
+};

package/dist/es/node_modules/toggle-selection/index.mjs

@@ -0,0 +1,25 @@
+var o = function() {
+  var e = document.getSelection();
+  if (!e.rangeCount)
+    return function() {
+    };
+  for (var t = document.activeElement, a = [], n = 0; n < e.rangeCount; n++)
+    a.push(e.getRangeAt(n));
+  switch (t.tagName.toUpperCase()) {
+    case "INPUT":
+    case "TEXTAREA":
+      t.blur();
+      break;
+    default:
+      t = null;
+      break;
+  }
+  return e.removeAllRanges(), function() {
+    e.type === "Caret" && e.removeAllRanges(), e.rangeCount || a.forEach(function(r) {
+      e.addRange(r);
+    }), t && t.focus();
+  };
+};
+export {
+  o as t
+};

package/dist/es/node_modules/tslib/tslib.es6.mjs

@@ -0,0 +1,15 @@
+function i(r) {
+  var e = typeof Symbol == "function" && Symbol.iterator, n = e && r[e], t = 0;
+  if (n)
+    return n.call(r);
+  if (r && typeof r.length == "number")
+    return {
+      next: function() {
+        return r && t >= r.length && (r = void 0), { value: r && r[t++], done: !r };
+      }
+    };
+  throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+export {
+  i as __values
+};

package/dist/es/node_modules/uuid/dist/esm-browser/native.mjs

@@ -0,0 +1,6 @@
+const o = typeof crypto != "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto), t = {
+  randomUUID: o
+};
+export {
+  t as default
+};

package/dist/es/node_modules/uuid/dist/esm-browser/rng.mjs

@@ -0,0 +1,10 @@
+let t;
+const e = new Uint8Array(16);
+function o() {
+  if (!t && (t = typeof crypto != "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !t))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return t(e);
+}
+export {
+  o as default
+};

package/dist/es/node_modules/uuid/dist/esm-browser/stringify.mjs

@@ -0,0 +1,9 @@
+const i = [];
+for (let n = 0; n < 256; ++n)
+  i.push((n + 256).toString(16).slice(1));
+function c(n, u = 0) {
+  return i[n[u + 0]] + i[n[u + 1]] + i[n[u + 2]] + i[n[u + 3]] + "-" + i[n[u + 4]] + i[n[u + 5]] + "-" + i[n[u + 6]] + i[n[u + 7]] + "-" + i[n[u + 8]] + i[n[u + 9]] + "-" + i[n[u + 10]] + i[n[u + 11]] + i[n[u + 12]] + i[n[u + 13]] + i[n[u + 14]] + i[n[u + 15]];
+}
+export {
+  c as unsafeStringify
+};

package/dist/es/node_modules/uuid/dist/esm-browser/v4.mjs

@@ -0,0 +1,19 @@
+import e from "./native.mjs";
+import i from "./rng.mjs";
+import { unsafeStringify as d } from "./stringify.mjs";
+function g(n, m, t) {
+  if (e.randomUUID && !m && !n)
+    return e.randomUUID();
+  n = n || {};
+  const r = n.random || (n.rng || i)();
+  if (r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128, m) {
+    t = t || 0;
+    for (let a = 0; a < 16; ++a)
+      m[t + a] = r[a];
+    return m;
+  }
+  return d(r);
+}
+export {
+  g as default
+};

package/dist/es/packages/agent-cli-sdk/src/AgentSession.mjs

@@ -0,0 +1,243 @@
+var C = Object.defineProperty, E = Object.defineProperties;
+var S = Object.getOwnPropertyDescriptors;
+var R = Object.getOwnPropertySymbols;
+var b = Object.prototype.hasOwnProperty, x = Object.prototype.propertyIsEnumerable;
+var A = (a, t, i) => t in a ? C(a, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : a[t] = i, l = (a, t) => {
+  for (var i in t || (t = {}))
+    b.call(t, i) && A(a, i, t[i]);
+  if (R)
+    for (var i of R(t))
+      x.call(t, i) && A(a, i, t[i]);
+  return a;
+}, y = (a, t) => E(a, S(t));
+var p = (a, t, i) => new Promise((h, n) => {
+  var s = (c) => {
+    try {
+      r(i.next(c));
+    } catch (m) {
+      n(m);
+    }
+  }, e = (c) => {
+    try {
+      r(i.throw(c));
+    } catch (m) {
+      n(m);
+    }
+  }, r = (c) => c.done ? h(c.value) : Promise.resolve(c.value).then(s, e);
+  r((i = i.apply(a, t)).next());
+});
+import "axios";
+import "../../../node_modules/@glodon-aiot/minio/dist/minio-zj.mjs";
+import "dayjs";
+import "../../apis/dist/es/node_modules/uuid/dist/esm-browser/native.mjs";
+import "../../apis/dist/es/node_modules/uuid/dist/esm-browser/stringify.mjs";
+import "../../apis/dist/es/agentcliui/index.mjs";
+import "../../apis/dist/es/aecpilotui/index.mjs";
+import { ChatMessageRole as k } from "../../apis/dist/es/cvforce/model.mjs";
+import L from "./Logger.mjs";
+import { configuration as w } from "./Config.mjs";
+import { io as U } from "../../../node_modules/socket.io-client/build/esm/index.mjs";
+import { UserMode as v } from "./PayloadTypes.mjs";
+import q, { SessionErrors as I } from "./Session.mjs";
+const u = new L("[AgentClient] ");
+class j extends q {
+  constructor(t, i = "", h, n) {
+    super(t, i, h, n);
+  }
+  prepareConnection() {
+    return new Promise((t) => p(this, null, function* () {
+      this.socket && t(!0);
+      const i = {
+        version: "1.0",
+        stream: "false",
+        appId: this._applicationId,
+        sessionId: this._id,
+        Authorization: `${this.token}`,
+        userMode: w.debug ? v.Debug : v.Normal
+      }, h = new URL(w.apiRoot), n = yield U(h.origin, {
+        path: h.pathname.replace("api", "socketio") + "/copilot",
+        query: i,
+        transports: ["websocket"]
+      });
+      n.on("connect", () => {
+        u.log("socket:connect"), this.event.emit("socket:connect"), n.emit("init");
+      }), n.on("disconnect", () => {
+        u.log("socket:disconnect"), this.event.emit("socket:disconnect");
+      }), n.on("ready", (s) => {
+        if (s.code === 200) {
+          u.log("ready");
+          const e = w.debug ? v.Debug : v.Normal;
+          e === v.Debug && e !== s.userMode && console.warn(I.UserModeError), this._ready || (this._ready = !0, this.event.emit("ready")), this.frozen = !1, t(!0);
+        } else {
+          this._ready && (this._ready = !1);
+          const e = new Error(
+            I.SocketConnectionFailed
+            // , {
+            //   cause: data,
+            // }
+          );
+          u.error("error", e), this.event.emit("error", e), t(!1);
+        }
+      }), n.on("action", (s, e) => p(this, null, function* () {
+        if (this._stopAnswer || !this._id)
+          return;
+        const {
+          type: r,
+          data: {
+            runnerIsClient: c,
+            pluginCode: m,
+            funcCode: g,
+            parameters: o,
+            requestBody: N
+          }
+        } = s, d = this.messages[this.messages.length - 1];
+        if (!d.messageId)
+          d.actions || (d.actions = []), d.actions[s.data.step - 1] || (d.actions[s.data.step - 1] = []), d.actions[s.data.step - 1].push(s), this.event.emit("message:action", {
+            messageId: d.messageId,
+            action: s
+          }), this.event.emit("message:updated", d);
+        else {
+          const f = {
+            messageId: "",
+            content: "",
+            role: k.Robot,
+            sessionId: this._id,
+            reference: [],
+            searchReference: [],
+            isLoading: !0,
+            messageTime: "",
+            actions: [[s]]
+          };
+          this.pushMessage(f), this.event.emit("message:action", {
+            messageId: f.messageId,
+            action: s
+          });
+        }
+        if (this.inactivating) {
+          const f = new Error(
+            I.Inactive
+            // {
+            //   cause: {
+            //     code: -1,
+            //     message:
+            //       'session is inactive, skipping plugin client function call',
+            //   },
+            // }
+          );
+          u.warn("error", f), this.event.emit("error", f);
+        } else if (r === "FUNCTION_CALL" && c) {
+          if (u.log(`calling function ${g} of plugin  ${m} with argument:
+ ${JSON.stringify(o)}`), !w.plugins[m]) {
+            e({
+              code: 404,
+              message: "对不起，没有找到插件。"
+            });
+            return;
+          }
+          const f = w.plugins[m].functions[g];
+          typeof f != "function" && e({
+            code: 404,
+            message: "对不起，没有找到插件方法。"
+          });
+          let _ = o == null ? void 0 : o.query;
+          try {
+            _ = JSON.parse(o == null ? void 0 : o.query);
+          } catch (M) {
+          }
+          f(_, (...M) => {
+            this._stopAnswer || e(...M);
+          });
+        }
+      })), n.on("answer", (s) => {
+        if (!this._stopAnswer)
+          if (s.data.code !== 200 && (s.data.index = -1, this.event.emit("error", s.data)), s.data.index === -1) {
+            let e = this.messages[this.messages.length - 1];
+            if (e && !e.messageId)
+              e = l(l({}, e), s.data), this.event.emit("message:content", e), this.event.emit("message:updated", e), this.event.emit("answer:finish", e);
+            else {
+              const r = l({
+                messageId: "",
+                content: "",
+                role: k.Robot,
+                sessionId: this._id,
+                reference: [],
+                searchReference: [],
+                isLoading: !1,
+                messageTime: "",
+                actions: []
+              }, s.data);
+              this.event.emit("message:content", r), this.pushMessage(r), this.event.emit("answer:finish", r);
+            }
+          } else {
+            let e = this.messages[this.messages.length - 1];
+            e && !e.messageId ? (e = l(l({}, e), s.data), this.messages[this.messages.length - 1] = e, this.event.emit("message:content", e), this.event.emit("message:updated", e)) : (this.pushMessage(s.data), this.event.emit("message:content", s.data));
+          }
+      }), n.on("reference", (s) => p(this, null, function* () {
+        if (this._stopAnswer)
+          return;
+        if (!this._id) {
+          const o = new Error(
+            I.IdUndefined
+            // {
+            //   cause: SESSION_ERROR_CAUSE[SessionErrors.IdUndefined],
+            // }
+          );
+          u.error(o), this.event.emit("error", o), this.frozen = !1;
+          return;
+        }
+        const {
+          type: e,
+          data: r,
+          requestId: c
+        } = s, m = this.messages.findIndex((o) => o.messageId === c && o.role === k.User);
+        if (m < 0)
+          return;
+        const g = m + 1;
+        if (g >= this.messages.length) {
+          const o = {
+            messageId: "",
+            content: "",
+            role: k.Robot,
+            sessionId: this._id,
+            reference: [],
+            searchReference: [],
+            isLoading: !0,
+            messageTime: "",
+            actions: []
+          };
+          this.pushMessage(o);
+        }
+        e === "KG" ? (this.messages[g] = y(l({}, this.messages[g]), {
+          reference: r.knowledgeReference
+        }), yield this.fillMessageReference(this.messages[g]), this.event.emit("message:reference", r.knowledgeReference), this.event.emit("message:updated", this.messages[g])) : e === "WEB_SEARCH" && (this.messages[g] = y(l({}, this.messages[g]), {
+          searchReference: r.knowledgeReference
+        }), this.event.emit("message:searchreference", r.searchReference), this.event.emit("message:updated", this.messages[g]));
+      })), this.socket = n, n.open();
+    }));
+  }
+  sendQuestion(t, i) {
+    return p(this, null, function* () {
+      var h, n;
+      if (!this.active) {
+        if (yield this.activate(), !this.socket) {
+          const s = new Error(
+            I.SocketConnectionFailed
+            // {
+            //   cause: { code: -1, message: 'socket is null' },
+            // }
+          );
+          return u.warn("error", s), this.event.emit("error", s), !1;
+        }
+        (h = this.socket) == null || h.emit("question", t);
+      }
+      (n = this.socket) == null || n.emit("question", t);
+    });
+  }
+  stopAnswer() {
+    var t;
+    (t = this.socket) == null || t.emit("stop_answer");
+  }
+}
+export {
+  j as default
+};