dingtalk-stream 2.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 钉钉开放平台团队
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# dingtalk-stream
+Nodejs SDK for DingTalk Stream Mode API, Compared with the webhook mode, it is easier to access the DingTalk chatbot
+钉钉支持 Stream 模式接入事件推送、机器人收消息以及卡片回调，该 SDK 实现了 Stream 模式。相比 Webhook 模式，Stream 模式可以更简单的接入各类事件和回调。
+
+## 快速开始
+npm ii
+npm start
+
+### 准备工作
+
+* Nodejs 开发环境，https://midwayjs.org/docs/how_to_install_nodejs
+* 需要Node version >= 18.17.1
+* 钉钉开发者账号，具备创建企业内部应用的权限，详见[成为钉钉开发者](https://open.dingtalk.com/document/orgapp/become-a-dingtalk-developer)
+
+### 快速开始指南
+
+1、创建企业内部应用
+
+进入[钉钉开发者后台](https://open-dev.dingtalk.com/)，创建企业内部应用，获取ClientID（即 AppKey）和ClientSecret（ 即AppSecret）。
+
+发布应用：在开发者后台左侧导航中，点击“版本管理与发布”，点击“确认发布”，并在接下来的可见范围设置中，选择“全部员工”，或者按需选择部分员工。
+
+
+2、Stream 模式的机器人（可选）
+
+如果不需要使用机器人功能的话，可以不用创建。
+
+在应用管理的左侧导航中，选择“消息推送”，打开机器人能力，设置机器人基本信息。
+
+注意：消息接收模式中，选择 “Stream 模式”
+
+![Stream 模式](https://img.alicdn.com/imgextra/i3/O1CN01XL4piO1lkYX2F6sW6_!!6000000004857-0-tps-896-522.jpg)
+
+点击“点击调试”按钮，可以创建测试群进行测试。
+
+3、使用demo项目测试，启动服务：
+
+a、获取demo项目 
+```Shell
+ git clone git@github.com:open-dingtalk/dingtalk-stream-sdk-nodejs.git
+```
+b、在example/config.json里配置应用信息。
+
+c、启动测试case
+```Shell
+cd dingtalk-stream
+yarn
+npm run build
+npm start
+```
+
+4、在项目中引用sdk，安装 dingtalk-stream
+
+```Shell
+npm i dingtalk-stream
+```
+
+代码中使用
+```javascript
+const DWClient = require("dingtalk-stream");
+const config = require("./config.json");
+
+const client = new DWClient({
+  clientId: config.clientId,
+  clientSecret: config.clientSecret,
+  debug: true // 开启调试信息，默认关闭
+});
+client.registerCallbackListener('/v1.0/im/bot/messages/get', async (res) => {
+    // 注册机器人回调事件
+    console.log("收到消息");
+    const {messageId} = res.headers;
+    const { text, senderStaffId, sessionWebhook } = JSON.parse(res.data);
+  })
+  .registerCallbackListener(
+    '/v1.0/graph/api/invoke',
+    async (res: DWClientDownStream) => {
+      // 注册AI插件回调事件
+      console.log("收到ai消息");
+      const { messageId } = res.headers;
+
+      // 添加业务逻辑
+      console.log(res);
+      console.log(JSON.parse(res.data));
+
+      // 通过Stream返回数据
+      client.sendGraphAPIResponse(messageId, {
+        response: {
+          statusLine: {
+            code: 200,
+            reasonPhrase: "OK",
+          },
+          headers: {},
+          body: JSON.stringify({
+            text: "你好",
+          }),
+        },
+      });
+    }
+  )
+  .connect();
+```
+
+### 事件订阅切换到 Stream 模式（可选）
+
+进入钉钉开发者后台，选择企业内部应用，在应用管理的左侧导航中，选择“事件与回调”。
+“订阅管理”中，“推送方式”选项中，选择 “Stream 模式”，并保存
+
+### AI 应用 - 技能插件，Graph API 类型插件使用 （可选）
+
+配置好魔法棒应用，并在技能中使用了Graph API类型插件。
+
+### 技术支持
+
+[点击链接，加入Stream模式共创群交流](https://open-dingtalk.github.io/developerpedia/docs/explore/support/?via=moon-group)

package/dist/client.cjs

@@ -0,0 +1,299 @@
+'use strict';
+
+var WebSocket = require('ws');
+var axios = require('axios');
+var EventEmitter = require('events');
+
+var EventAck = /* @__PURE__ */ ((EventAck2) => {
+  EventAck2["SUCCESS"] = "SUCCESS";
+  EventAck2["LATER"] = "LATER";
+  return EventAck2;
+})(EventAck || {});
+const defaultConfig = {
+  autoReconnect: true,
+  keepAlive: false,
+  ua: "",
+  subscriptions: [
+    {
+      type: "EVENT",
+      topic: "*"
+    }
+  ]
+};
+class DWClient extends EventEmitter {
+  debug = false;
+  connected = false;
+  registered = false;
+  reconnecting = false;
+  userDisconnect = false;
+  reconnectInterval = 1e3;
+  heartbeat_interval = 8e3;
+  heartbeatIntervallId;
+  sslopts = { rejectUnauthorized: true };
+  config;
+  socket;
+  dw_url;
+  isAlive = false;
+  onEventReceived = (msg) => {
+    return { status: "SUCCESS" /* SUCCESS */ };
+  };
+  constructor(opts) {
+    super();
+    this.config = {
+      ...defaultConfig,
+      ...opts
+    };
+    if (!this.config.clientId || !this.config.clientSecret) {
+      console.error("clientId or clientSecret is null");
+      throw new Error("clientId or clientSecret is null");
+    }
+    if (this.config.debug !== void 0) {
+      this.debug = this.config.debug;
+    }
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  printDebug(msg) {
+    if (this.debug) {
+      const date = "[" + (/* @__PURE__ */ new Date()).toISOString() + "]";
+      console.info(date, msg);
+    }
+  }
+  registerAllEventListener(onEventReceived) {
+    this.onEventReceived = onEventReceived;
+    return this;
+  }
+  registerCallbackListener(eventId, callback) {
+    if (!eventId || !callback) {
+      console.error(
+        "registerCallbackListener: eventId and callback must be defined"
+      );
+      throw new Error(
+        "registerCallbackListener: eventId and callback must be defined"
+      );
+    }
+    if (!this.config.subscriptions.find(
+      (x) => x.topic === eventId && x.type === "CALLBACK"
+    )) {
+      this.config.subscriptions.push({
+        type: "CALLBACK",
+        topic: eventId
+      });
+    }
+    this.on(eventId, callback);
+    return this;
+  }
+  async getEndpoint() {
+    this.printDebug("get connect endpoint by config");
+    this.printDebug(this.config);
+    const result = await axios.get(
+      `https://oapi.dingtalk.com/gettoken?appkey=${this.config.clientId}&appsecret=${this.config.clientSecret}`
+    );
+    if (result.status === 200 && result.data.access_token) {
+      this.config.access_token = result.data.access_token;
+      const res = await axios({
+        url: "https://pre-api.dingtalk.com/v1.0/gateway/connections/open",
+        method: "POST",
+        responseType: "json",
+        data: {
+          clientId: this.config.clientId,
+          clientSecret: this.config.clientSecret,
+          ua: this.config.ua,
+          subscriptions: this.config.subscriptions
+        },
+        headers: {
+          // 这个接口得加个，否则默认返回的会是xml
+          Accept: "application/json",
+          "access-token": result.data.access_token
+          // 'd136e657-5998-4cc4-a055-2b7ceab0f212'
+        }
+      });
+      this.printDebug("res.data " + JSON.stringify(res.data));
+      if (res.data) {
+        this.config.endpoint = res.data;
+        const { endpoint, ticket } = res.data;
+        if (!endpoint || !ticket) {
+          this.printDebug("endpoint or ticket is null");
+          throw new Error("endpoint or ticket is null");
+        }
+        this.dw_url = `${endpoint}?ticket=${ticket}`;
+        return this;
+      } else {
+        throw new Error("build: get endpoint failed");
+      }
+    } else {
+      throw new Error("build: get access_token failed");
+    }
+  }
+  _connect() {
+    return new Promise((resolve, reject) => {
+      this.userDisconnect = false;
+      this.printDebug("Connecting to dingtalk websocket @ " + this.dw_url);
+      this.socket = new WebSocket(this.dw_url, this.sslopts);
+      this.socket.on("open", () => {
+        this.connected = true;
+        this.printDebug("Socket open");
+        if (this.config.keepAlive) {
+          this.isAlive = true;
+          this.heartbeatIntervallId = setInterval(() => {
+            var _a, _b;
+            if (this.isAlive === false) {
+              console.error(
+                "TERMINATE SOCKET: Ping Pong does not transfer heartbeat within heartbeat intervall"
+              );
+              return (_a = this.socket) == null ? void 0 : _a.terminate();
+            }
+            this.isAlive = false;
+            (_b = this.socket) == null ? void 0 : _b.ping("", true);
+          }, this.heartbeat_interval);
+        }
+      });
+      this.socket.on("pong", () => {
+        this.heartbeat();
+      });
+      this.socket.on("message", (data) => {
+        this.onDownStream(data);
+      });
+      this.socket.on("close", (err) => {
+        this.printDebug("Socket closed");
+        this.connected = false;
+        this.registered = false;
+        if (this.config.autoReconnect && !this.userDisconnect) {
+          this.reconnecting = true;
+          this.printDebug(
+            "Reconnecting in " + this.reconnectInterval / 1e3 + " seconds..."
+          );
+          setTimeout(this.connect.bind(this), this.reconnectInterval);
+        }
+      });
+      this.socket.on("error", (err) => {
+        this.printDebug("SOCKET ERROR");
+        console.warn("ERROR", err);
+      });
+      resolve();
+    });
+  }
+  async connect() {
+    await this.getEndpoint();
+    await this._connect();
+  }
+  disconnect() {
+    var _a;
+    console.info("Disconnecting.");
+    this.userDisconnect = true;
+    if (this.config.keepAlive && this.heartbeatIntervallId !== void 0) {
+      clearInterval(this.heartbeatIntervallId);
+    }
+    (_a = this.socket) == null ? void 0 : _a.close();
+  }
+  heartbeat() {
+    this.isAlive = true;
+    this.printDebug("CLIENT-SIDE HEARTBEAT");
+  }
+  onDownStream(data) {
+    this.printDebug("Received message from dingtalk websocket server");
+    this.printDebug(data);
+    const msg = JSON.parse(data);
+    switch (msg.type) {
+      case "SYSTEM":
+        this.onSystem(msg);
+        break;
+      case "EVENT":
+        this.onEvent(msg);
+        break;
+      case "CALLBACK":
+        this.onCallback(msg);
+        break;
+    }
+  }
+  onSystem(downstream) {
+    var _a;
+    switch (downstream.headers.topic) {
+      case "CONNECTED": {
+        this.printDebug("CONNECTED");
+        break;
+      }
+      case "REGISTERED": {
+        this.registered = true;
+        this.reconnecting = false;
+        break;
+      }
+      case "disconnect": {
+        this.connected = false;
+        this.registered = false;
+        break;
+      }
+      case "KEEPALIVE": {
+        this.heartbeat();
+        break;
+      }
+      case "ping": {
+        this.printDebug("PING");
+        (_a = this.socket) == null ? void 0 : _a.send(
+          JSON.stringify({
+            code: 200,
+            headers: downstream.headers,
+            message: "OK",
+            data: downstream.data
+          })
+        );
+        break;
+      }
+    }
+  }
+  onEvent(message) {
+    var _a;
+    this.printDebug("received event, message=" + JSON.stringify(message));
+    const ackData = this.onEventReceived(message);
+    (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify({
+      code: 200,
+      headers: {
+        contentType: "application/json",
+        messageId: message.headers.messageId
+      },
+      message: "OK",
+      data: JSON.stringify(ackData)
+    }));
+  }
+  onCallback(message) {
+    this.emit(message.headers.topic, message);
+  }
+  send(messageId, value) {
+    var _a;
+    if (!messageId) {
+      console.error("send: messageId must be defined");
+      throw new Error("send: messageId must be defined");
+    }
+    const msg = {
+      code: 200,
+      headers: {
+        contentType: "application/json",
+        messageId
+      },
+      message: "OK",
+      data: JSON.stringify(value)
+    };
+    (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify(msg));
+  }
+  sendGraphAPIResponse(messageId, value) {
+    var _a;
+    if (!messageId) {
+      console.error("send: messageId must be defined");
+      throw new Error("send: messageId must be defined");
+    }
+    const msg = {
+      code: 200,
+      headers: {
+        contentType: "application/json",
+        messageId
+      },
+      message: "OK",
+      data: JSON.stringify(value)
+    };
+    (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify(msg));
+  }
+}
+
+exports.DWClient = DWClient;
+exports.EventAck = EventAck;

package/dist/client.d.ts

@@ -0,0 +1,99 @@
+import { GraphAPIResponse } from './constants.js';
+import EventEmitter from 'events';
+
+declare enum EventAck {
+    SUCCESS = "SUCCESS",
+    LATER = "LATER"
+}
+interface EventAckData {
+    status: EventAck;
+    message?: string;
+}
+interface DWClientConfig {
+    clientId: string;
+    clientSecret: string;
+    keepAlive?: boolean;
+    debug?: boolean;
+    ua?: string;
+    endpoint?: string;
+    access_token?: string;
+    autoReconnect?: boolean;
+    subscriptions: Array<{
+        type: string;
+        topic: string;
+    }>;
+}
+interface DWClientDownStream {
+    specVersion: string;
+    type: string;
+    headers: {
+        appId: string;
+        connectionId: string;
+        contentType: string;
+        messageId: string;
+        time: string;
+        topic: string;
+        eventType?: string;
+        eventBornTime?: string;
+        eventId?: string;
+        eventCorpId?: string;
+        eventUnifiedAppId?: string;
+    };
+    data: string;
+}
+interface OnEventReceived {
+    (msg: DWClientDownStream): EventAckData;
+}
+declare class DWClient extends EventEmitter {
+    debug: boolean;
+    connected: boolean;
+    registered: boolean;
+    reconnecting: boolean;
+    private userDisconnect;
+    private reconnectInterval;
+    private heartbeat_interval;
+    private heartbeatIntervallId?;
+    private sslopts;
+    readonly config: DWClientConfig;
+    private socket?;
+    private dw_url?;
+    private isAlive;
+    private onEventReceived;
+    constructor(opts: {
+        clientId: string;
+        clientSecret: string;
+        ua?: string;
+        keepAlive?: boolean;
+        debug?: boolean;
+    });
+    getConfig(): {
+        clientId: string;
+        clientSecret: string;
+        keepAlive?: boolean | undefined;
+        debug?: boolean | undefined;
+        ua?: string | undefined;
+        endpoint?: string | undefined;
+        access_token?: string | undefined;
+        autoReconnect?: boolean | undefined;
+        subscriptions: {
+            type: string;
+            topic: string;
+        }[];
+    };
+    printDebug(msg: object | string): void;
+    registerAllEventListener(onEventReceived: (v: DWClientDownStream) => EventAckData): this;
+    registerCallbackListener(eventId: string, callback: (v: DWClientDownStream) => void): this;
+    getEndpoint(): Promise<this>;
+    _connect(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): void;
+    heartbeat(): void;
+    onDownStream(data: string): void;
+    onSystem(downstream: DWClientDownStream): void;
+    onEvent(message: DWClientDownStream): void;
+    onCallback(message: DWClientDownStream): void;
+    send(messageId: string, value: any): void;
+    sendGraphAPIResponse(messageId: string, value: GraphAPIResponse): void;
+}
+
+export { DWClient, type DWClientConfig, type DWClientDownStream, EventAck, type EventAckData, type OnEventReceived };

package/dist/client.mjs

@@ -0,0 +1,296 @@
+import WebSocket from 'ws';
+import axios from 'axios';
+import EventEmitter from 'events';
+
+var EventAck = /* @__PURE__ */ ((EventAck2) => {
+  EventAck2["SUCCESS"] = "SUCCESS";
+  EventAck2["LATER"] = "LATER";
+  return EventAck2;
+})(EventAck || {});
+const defaultConfig = {
+  autoReconnect: true,
+  keepAlive: false,
+  ua: "",
+  subscriptions: [
+    {
+      type: "EVENT",
+      topic: "*"
+    }
+  ]
+};
+class DWClient extends EventEmitter {
+  debug = false;
+  connected = false;
+  registered = false;
+  reconnecting = false;
+  userDisconnect = false;
+  reconnectInterval = 1e3;
+  heartbeat_interval = 8e3;
+  heartbeatIntervallId;
+  sslopts = { rejectUnauthorized: true };
+  config;
+  socket;
+  dw_url;
+  isAlive = false;
+  onEventReceived = (msg) => {
+    return { status: "SUCCESS" /* SUCCESS */ };
+  };
+  constructor(opts) {
+    super();
+    this.config = {
+      ...defaultConfig,
+      ...opts
+    };
+    if (!this.config.clientId || !this.config.clientSecret) {
+      console.error("clientId or clientSecret is null");
+      throw new Error("clientId or clientSecret is null");
+    }
+    if (this.config.debug !== void 0) {
+      this.debug = this.config.debug;
+    }
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  printDebug(msg) {
+    if (this.debug) {
+      const date = "[" + (/* @__PURE__ */ new Date()).toISOString() + "]";
+      console.info(date, msg);
+    }
+  }
+  registerAllEventListener(onEventReceived) {
+    this.onEventReceived = onEventReceived;
+    return this;
+  }
+  registerCallbackListener(eventId, callback) {
+    if (!eventId || !callback) {
+      console.error(
+        "registerCallbackListener: eventId and callback must be defined"
+      );
+      throw new Error(
+        "registerCallbackListener: eventId and callback must be defined"
+      );
+    }
+    if (!this.config.subscriptions.find(
+      (x) => x.topic === eventId && x.type === "CALLBACK"
+    )) {
+      this.config.subscriptions.push({
+        type: "CALLBACK",
+        topic: eventId
+      });
+    }
+    this.on(eventId, callback);
+    return this;
+  }
+  async getEndpoint() {
+    this.printDebug("get connect endpoint by config");
+    this.printDebug(this.config);
+    const result = await axios.get(
+      `https://oapi.dingtalk.com/gettoken?appkey=${this.config.clientId}&appsecret=${this.config.clientSecret}`
+    );
+    if (result.status === 200 && result.data.access_token) {
+      this.config.access_token = result.data.access_token;
+      const res = await axios({
+        url: "https://pre-api.dingtalk.com/v1.0/gateway/connections/open",
+        method: "POST",
+        responseType: "json",
+        data: {
+          clientId: this.config.clientId,
+          clientSecret: this.config.clientSecret,
+          ua: this.config.ua,
+          subscriptions: this.config.subscriptions
+        },
+        headers: {
+          // 这个接口得加个，否则默认返回的会是xml
+          Accept: "application/json",
+          "access-token": result.data.access_token
+          // 'd136e657-5998-4cc4-a055-2b7ceab0f212'
+        }
+      });
+      this.printDebug("res.data " + JSON.stringify(res.data));
+      if (res.data) {
+        this.config.endpoint = res.data;
+        const { endpoint, ticket } = res.data;
+        if (!endpoint || !ticket) {
+          this.printDebug("endpoint or ticket is null");
+          throw new Error("endpoint or ticket is null");
+        }
+        this.dw_url = `${endpoint}?ticket=${ticket}`;
+        return this;
+      } else {
+        throw new Error("build: get endpoint failed");
+      }
+    } else {
+      throw new Error("build: get access_token failed");
+    }
+  }
+  _connect() {
+    return new Promise((resolve, reject) => {
+      this.userDisconnect = false;
+      this.printDebug("Connecting to dingtalk websocket @ " + this.dw_url);
+      this.socket = new WebSocket(this.dw_url, this.sslopts);
+      this.socket.on("open", () => {
+        this.connected = true;
+        this.printDebug("Socket open");
+        if (this.config.keepAlive) {
+          this.isAlive = true;
+          this.heartbeatIntervallId = setInterval(() => {
+            var _a, _b;
+            if (this.isAlive === false) {
+              console.error(
+                "TERMINATE SOCKET: Ping Pong does not transfer heartbeat within heartbeat intervall"
+              );
+              return (_a = this.socket) == null ? void 0 : _a.terminate();
+            }
+            this.isAlive = false;
+            (_b = this.socket) == null ? void 0 : _b.ping("", true);
+          }, this.heartbeat_interval);
+        }
+      });
+      this.socket.on("pong", () => {
+        this.heartbeat();
+      });
+      this.socket.on("message", (data) => {
+        this.onDownStream(data);
+      });
+      this.socket.on("close", (err) => {
+        this.printDebug("Socket closed");
+        this.connected = false;
+        this.registered = false;
+        if (this.config.autoReconnect && !this.userDisconnect) {
+          this.reconnecting = true;
+          this.printDebug(
+            "Reconnecting in " + this.reconnectInterval / 1e3 + " seconds..."
+          );
+          setTimeout(this.connect.bind(this), this.reconnectInterval);
+        }
+      });
+      this.socket.on("error", (err) => {
+        this.printDebug("SOCKET ERROR");
+        console.warn("ERROR", err);
+      });
+      resolve();
+    });
+  }
+  async connect() {
+    await this.getEndpoint();
+    await this._connect();
+  }
+  disconnect() {
+    var _a;
+    console.info("Disconnecting.");
+    this.userDisconnect = true;
+    if (this.config.keepAlive && this.heartbeatIntervallId !== void 0) {
+      clearInterval(this.heartbeatIntervallId);
+    }
+    (_a = this.socket) == null ? void 0 : _a.close();
+  }
+  heartbeat() {
+    this.isAlive = true;
+    this.printDebug("CLIENT-SIDE HEARTBEAT");
+  }
+  onDownStream(data) {
+    this.printDebug("Received message from dingtalk websocket server");
+    this.printDebug(data);
+    const msg = JSON.parse(data);
+    switch (msg.type) {
+      case "SYSTEM":
+        this.onSystem(msg);
+        break;
+      case "EVENT":
+        this.onEvent(msg);
+        break;
+      case "CALLBACK":
+        this.onCallback(msg);
+        break;
+    }
+  }
+  onSystem(downstream) {
+    var _a;
+    switch (downstream.headers.topic) {
+      case "CONNECTED": {
+        this.printDebug("CONNECTED");
+        break;
+      }
+      case "REGISTERED": {
+        this.registered = true;
+        this.reconnecting = false;
+        break;
+      }
+      case "disconnect": {
+        this.connected = false;
+        this.registered = false;
+        break;
+      }
+      case "KEEPALIVE": {
+        this.heartbeat();
+        break;
+      }
+      case "ping": {
+        this.printDebug("PING");
+        (_a = this.socket) == null ? void 0 : _a.send(
+          JSON.stringify({
+            code: 200,
+            headers: downstream.headers,
+            message: "OK",
+            data: downstream.data
+          })
+        );
+        break;
+      }
+    }
+  }
+  onEvent(message) {
+    var _a;
+    this.printDebug("received event, message=" + JSON.stringify(message));
+    const ackData = this.onEventReceived(message);
+    (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify({
+      code: 200,
+      headers: {
+        contentType: "application/json",
+        messageId: message.headers.messageId
+      },
+      message: "OK",
+      data: JSON.stringify(ackData)
+    }));
+  }
+  onCallback(message) {
+    this.emit(message.headers.topic, message);
+  }
+  send(messageId, value) {
+    var _a;
+    if (!messageId) {
+      console.error("send: messageId must be defined");
+      throw new Error("send: messageId must be defined");
+    }
+    const msg = {
+      code: 200,
+      headers: {
+        contentType: "application/json",
+        messageId
+      },
+      message: "OK",
+      data: JSON.stringify(value)
+    };
+    (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify(msg));
+  }
+  sendGraphAPIResponse(messageId, value) {
+    var _a;
+    if (!messageId) {
+      console.error("send: messageId must be defined");
+      throw new Error("send: messageId must be defined");
+    }
+    const msg = {
+      code: 200,
+      headers: {
+        contentType: "application/json",
+        messageId
+      },
+      message: "OK",
+      data: JSON.stringify(value)
+    };
+    (_a = this.socket) == null ? void 0 : _a.send(JSON.stringify(msg));
+  }
+}
+
+export { DWClient, EventAck };

package/dist/constants.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const TOPIC_ROBOT = "/v1.0/im/bot/messages/get";
+const TOPIC_CARD = "/v1.0/card/instances/callback";
+const TOPIC_AI_GRAPH_API = "/v1.0/graph/api/invoke";
+
+exports.TOPIC_AI_GRAPH_API = TOPIC_AI_GRAPH_API;
+exports.TOPIC_CARD = TOPIC_CARD;
+exports.TOPIC_ROBOT = TOPIC_ROBOT;

package/dist/constants.d.ts

@@ -0,0 +1,44 @@
+/** 机器人消息回调 */
+declare const TOPIC_ROBOT = "/v1.0/im/bot/messages/get";
+/** 卡片回调 */
+declare const TOPIC_CARD = "/v1.0/card/instances/callback";
+/** AI Graph API 插件消息回调 */
+declare const TOPIC_AI_GRAPH_API = "/v1.0/graph/api/invoke";
+interface RobotMessageBase {
+    conversationId: string;
+    chatbotCorpId: string;
+    chatbotUserId: string;
+    msgId: string;
+    senderNick: string;
+    isAdmin: boolean;
+    senderStaffId: string;
+    sessionWebhookExpiredTime: number;
+    createAt: number;
+    senderCorpId: string;
+    conversationType: string;
+    senderId: string;
+    sessionWebhook: string;
+    robotCode: string;
+    msgtype: string;
+}
+interface RobotTextMessage extends RobotMessageBase {
+    msgtype: 'text';
+    text: {
+        content: string;
+    };
+}
+interface GraphAPIResponse {
+    response: {
+        statusLine: {
+            code?: number;
+            reasonPhrase?: string;
+        };
+        headers: {
+            [key: string]: string;
+        };
+        body: string;
+    };
+}
+type RobotMessage = RobotTextMessage;
+
+export { type GraphAPIResponse, type RobotMessage, type RobotTextMessage, TOPIC_AI_GRAPH_API, TOPIC_CARD, TOPIC_ROBOT };

package/dist/constants.mjs

@@ -0,0 +1,5 @@
+const TOPIC_ROBOT = "/v1.0/im/bot/messages/get";
+const TOPIC_CARD = "/v1.0/card/instances/callback";
+const TOPIC_AI_GRAPH_API = "/v1.0/graph/api/invoke";
+
+export { TOPIC_AI_GRAPH_API, TOPIC_CARD, TOPIC_ROBOT };

package/dist/index.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var client = require('./client.cjs');
+require('ws');
+require('axios');
+require('events');
+
+
+
+exports.TOPIC_AI_GRAPH_API = constants.TOPIC_AI_GRAPH_API;
+exports.TOPIC_CARD = constants.TOPIC_CARD;
+exports.TOPIC_ROBOT = constants.TOPIC_ROBOT;
+exports.DWClient = client.DWClient;
+exports.EventAck = client.EventAck;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { GraphAPIResponse, RobotMessage, RobotTextMessage, TOPIC_AI_GRAPH_API, TOPIC_CARD, TOPIC_ROBOT } from './constants.js';
+export { DWClient, DWClientConfig, DWClientDownStream, EventAck, EventAckData, OnEventReceived } from './client.js';
+import 'events';

package/dist/index.mjs

@@ -0,0 +1,5 @@
+export { TOPIC_AI_GRAPH_API, TOPIC_CARD, TOPIC_ROBOT } from './constants.mjs';
+export { DWClient, EventAck } from './client.mjs';
+import 'ws';
+import 'axios';
+import 'events';

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "dingtalk-stream",
+  "version": "2.1.0",
+  "description": "Nodejs SDK for DingTalk Stream Mode API, Compared with the webhook mode, it is easier to access the DingTalk",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "require": "./dist/client.cjs",
+      "import": "./dist/client.mjs"
+    },
+    "./constants": {
+      "types": "./dist/constants.d.ts",
+      "require": "./dist/constants.cjs",
+      "import": "./dist/constants.mjs"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "start": "ts-node-esm example/index.ts",
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch --watch.include 'src/**' -m inline",
+    "prepublishOnly": "pnpm build",
+    "typecheck": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-dingtalk/dingtalk-stream-sdk-nodejs.git"
+  },
+  "keywords": [
+    "DingTalk Stream Mode",
+    "Nodejs",
+    "SDK"
+  ],
+  "author": "junlong.hjl@alibaba-inc.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/open-dingtalk/dingtalk-stream-sdk-nodejs/issues"
+  },
+  "files": [
+    "dist",
+    "*.d.ts",
+    "*.mjs"
+  ],
+  "homepage": "https://github.com/open-dingtalk/dingtalk-stream-sdk-nodejs#readme",
+  "dependencies": {
+    "axios": "^1.4.0",
+    "debug": "^4.3.4",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-alias": "^5.0.0",
+    "@rollup/plugin-commonjs": "^25.0.4",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.2.0",
+    "@types/debug": "^4.1.8",
+    "@types/node": ">=16",
+    "@types/ws": "^8.5.5",
+    "rimraf": "^5.0.1",
+    "rollup": "^3.28.0",
+    "rollup-plugin-dts": "^6.0.0",
+    "rollup-plugin-esbuild": "^5.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6",
+    "vite": "^4.4.9"
+  }
+}

package/vite-node.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('./dist/cli.mjs');