openclaw-stepfun 0.2.2

package/dist/src/websocket/index.js

@@ -0,0 +1,637 @@
+import { ErrorRes, HeartbeatReq, StreamMsg, } from "./streamConnect.js";
+import { BotAuthBindReq, BotAuthBindRes, } from "../proto/capy/botway/stream_pb.js";
+import { CacheEvent } from "./cacheEvent.js";
+// import { useAuthStore } from '@/store/authInfo';
+import { commonEventBus, Event } from "./eventBus.js";
+// import { refreshToken } from "..";
+import { BASE_URL, Env } from "./constant.js";
+import { MethodKind } from "@bufbuild/protobuf";
+const cache = new CacheEvent();
+export const uuid = () => {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+export var SocketConnectState;
+(function (SocketConnectState) {
+    SocketConnectState["Initial"] = "initial";
+    SocketConnectState["Connecting"] = "connecting";
+    SocketConnectState["Connected"] = "connected";
+    SocketConnectState["Token"] = "token";
+    SocketConnectState["Auth"] = "auth";
+    SocketConnectState["Disconnect"] = "disconnect";
+})(SocketConnectState || (SocketConnectState = {}));
+export var AuthState;
+(function (AuthState) {
+    // 鉴权状态
+    AuthState["Initial"] = "initial";
+    AuthState["Anonymous"] = "anonymous";
+    AuthState["User"] = "user";
+})(AuthState || (AuthState = {}));
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["Common"] = 1] = "Common";
+    ErrorCode[ErrorCode["Auth"] = 2] = "Auth";
+    ErrorCode[ErrorCode["Socket"] = 3] = "Socket";
+    ErrorCode[ErrorCode["Login"] = -1006] = "Login";
+})(ErrorCode || (ErrorCode = {}));
+// 鉴权包错误
+export var AuthSocketError;
+(function (AuthSocketError) {
+    // 鉴权失败，未知原因
+    AuthSocketError[AuthSocketError["AuthCodeFail"] = -1001] = "AuthCodeFail";
+    // 鉴权失败，access token过期
+    AuthSocketError[AuthSocketError["AuthCodeExpired"] = -1002] = "AuthCodeExpired";
+    // 鉴权失败，用户被封禁
+    AuthSocketError[AuthSocketError["AuthCodeBanned"] = -1003] = "AuthCodeBanned";
+    // 鉴权失败，用户未被激活
+    AuthSocketError[AuthSocketError["AuthCodeNotActivated"] = -1004] = "AuthCodeNotActivated";
+})(AuthSocketError || (AuthSocketError = {}));
+export var WebsocketCloseCode;
+(function (WebsocketCloseCode) {
+    // CloseCodeNormal 正常关闭
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeNormal"] = 1000] = "CloseCodeNormal";
+    // 客户端主动断连
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeErrorClient"] = 1001] = "CloseCodeErrorClient";
+    // 客户端主动断连
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeClient"] = 1006] = "CloseCodeClient";
+    // CloseCodeAuthFailed 鉴权失败
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeAuthFailed"] = 4001] = "CloseCodeAuthFailed";
+    //CloseCodeAuthTimeout 鉴权超时失败
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeAuthTimeout"] = 4002] = "CloseCodeAuthTimeout";
+    //CloseCodeHeartbeatTimeout 心跳超时失败
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeHeartbeatTimeout"] = 4003] = "CloseCodeHeartbeatTimeout";
+    // CloseCodeSameUserReconnect 同用户连接冲突
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeSameUserReconnect"] = 4004] = "CloseCodeSameUserReconnect";
+    // CloseCodeKickOut 踢下线
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeKickOut"] = 4005] = "CloseCodeKickOut";
+    // CloseCodeUserForbidden 用户封禁
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeUserForbidden"] = 4006] = "CloseCodeUserForbidden";
+    // CloseCodeParseMsgFailed 解析数据失败
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeParseMsgFailed"] = 4007] = "CloseCodeParseMsgFailed";
+    // CloseCodeServerRestart 服务重启
+    WebsocketCloseCode[WebsocketCloseCode["CloseCodeServerRestart"] = 4008] = "CloseCodeServerRestart";
+})(WebsocketCloseCode || (WebsocketCloseCode = {}));
+const RECONNECT_CODES = [
+    WebsocketCloseCode.CloseCodeNormal,
+    WebsocketCloseCode.CloseCodeErrorClient,
+    WebsocketCloseCode.CloseCodeClient,
+    // WebsocketCloseCode.CloseCodeAuthTimeout,
+    WebsocketCloseCode.CloseCodeHeartbeatTimeout,
+    WebsocketCloseCode.CloseCodeParseMsgFailed,
+    WebsocketCloseCode.CloseCodeServerRestart,
+];
+const RETRY_MAX = 3;
+const CONNECT_RETRY_MAX = 7;
+const socketEvent = new Event();
+class _Socket {
+    _conn = null;
+    // static isConnected = false
+    // static _connecting = 0
+    _state = SocketConnectState.Initial; // 当前的连接状态
+    _authState = AuthState.Initial; // 当前的鉴权状态
+    _sendQueue = [];
+    _connectId = null;
+    _retryAuthTime = 0; // 鉴权重试次数
+    _retryConnectTime = 0; // 重连重试次数
+    _heartHandler = null; // todo
+    _requestTasks = new Set();
+    _requestStreams = new Set();
+    auth = null;
+    heartbeatTime = 30 * 1000;
+    errorCount = 0;
+    testCount = 0;
+    limit = 5;
+    events = socketEvent;
+    onAuthErr;
+    onAuthSuccess;
+    constructor(options) {
+        this.heartbeatTime = options?.heartbeatTime || this.heartbeatTime;
+        this.onAuthErr = options?.onAuthErr;
+        this.onAuthSuccess = options?.onAuthSuccess;
+        if (!options?.ignoreCreate) {
+            // Use void to explicitly mark this as intentionally unawaited
+            // Errors are handled internally by the socket's event system
+            void this.create("new socket").catch((err) => {
+                console.error("[websocket] Constructor create failed:", err);
+                // Error is logged but not thrown, to prevent affecting the gateway
+            });
+        }
+        commonEventBus.on("tokenUpdate", () => {
+            // Wrap sendAuth to catch any errors and prevent unhandled rejections
+            this.sendAuth().catch((err) => {
+                console.error("[websocket] sendAuth failed:", err);
+            });
+        });
+    }
+    // Custom WebSocket URL
+    _customWsUrl;
+    async create(scene, url) {
+        if (this._state !== SocketConnectState.Initial && this._conn) {
+            console.log(`[websocket] create skipped - already has connection (state: ${this._state})`);
+            return this._conn;
+        }
+        const wsUrl = url || this._customWsUrl || BASE_URL[Env.Prod].ws;
+        console.log(`[websocket] creating new connection - scene: "${scene}", url: ${wsUrl.replace(/token=[^&]+/, "token=***")}`);
+        this._state = SocketConnectState.Connecting; // 将状态变更为连接中
+        const conn = new WebSocket(wsUrl);
+        conn.binaryType = "arraybuffer";
+        this._conn = conn;
+        cache.clear();
+        // Add event handlers BEFORE awaiting initAuth to avoid race condition
+        // where WebSocket connects before handlers are attached
+        this.addConnEvents();
+        try {
+            await this.initAuth();
+        }
+        catch (err) {
+            console.error("[websocket] initAuth failed in create:", err);
+            // Don't throw - let the connection attempt continue
+            // The auth will be retried or the connection will fail naturally
+        }
+        this._state = SocketConnectState.Connecting; // 将状态变更为连接中
+        return conn;
+    }
+    /**
+     * Set custom WebSocket URL
+     */
+    setUrl(url) {
+        this._customWsUrl = url;
+    }
+    /**
+     * Set authentication credentials
+     */
+    setAuth(token, appId) {
+        this.auth = new BotAuthBindReq({
+            token,
+            appId,
+        });
+    }
+    async initAuth() {
+        // 获取鉴权信息
+        try {
+            // Auth should be set externally via setAuth() before connection
+            // If not set, we'll wait for it to be set later
+            if (!this.auth) {
+                console.log("[websocket]initAuth: auth not set, waiting for setAuth() call");
+                // Don't throw error, just don't complete the cache
+                // The connection will wait for auth to be set
+                return;
+            }
+            console.log("[websocket]initAuth", this.auth.token);
+            cache.complete("getToken");
+        }
+        catch (e) {
+            console.error("[websocket]initAuth error:", e);
+            // Use setTimeout to avoid stack overflow from recursive calls
+            if (this._retryAuthTime < RETRY_MAX) {
+                this._retryAuthTime += 1;
+                setTimeout(() => {
+                    void this.initAuth();
+                }, 1000 * this._retryAuthTime); // Exponential backoff
+            }
+            else {
+                console.error("[websocket]initAuth: max retries exceeded");
+            }
+        }
+    }
+    addConnEvents() {
+        if (!this._conn)
+            return;
+        const { _conn } = this;
+        if (_conn.onmessage)
+            return;
+        _conn.onopen = () => {
+            console.log(`[websocket] WebSocket connected - transitioning to auth phase`);
+            this._state = SocketConnectState.Connected;
+            cache.do(async () => {
+                this._state = SocketConnectState.Token; // 保证状态变化的线性，所以在connected后再变更状态至token
+                try {
+                    await this.sendAuth();
+                    console.log(`[websocket] connection fully established - auth successful, state: ${this._state}`);
+                    this.events.emit("open");
+                    this.errorCount = 0;
+                }
+                catch (err) {
+                    // Auth failed - this is expected when credentials are invalid
+                    // Error is already logged by sendAuth, just ensure we don't crash
+                    console.error("[websocket] Auth failed in onopen:", err);
+                    // Don't rethrow - let the connection close and retry handle it
+                }
+            }, ["getToken"]);
+        };
+        _conn.onmessage = (event) => {
+            // 假如是心跳包，只发不解
+            if (event.data instanceof ArrayBuffer) {
+                const uint8Array = new Uint8Array(event.data);
+                const { body, head } = StreamMsg.fromBinary(uint8Array);
+                this.events.emit("message", body);
+                // this.testCount++;
+                // if (this.testCount >= this.limit) {
+                //   console.log('==lin==manual onclose');
+                //   _conn.onclose?.(
+                //     new CloseEvent('', {
+                //       code: WebsocketCloseCode.CloseCodeClient,
+                //     }),
+                //   );
+                //   this.testCount = 0;
+                //   this.limit = this.limit * 2;
+                // }
+                if (head?.msgType === 4 || !body) {
+                    // todo 要定义枚举值
+                    const error = body
+                        ? ErrorRes.fromBinary(body)
+                        : new ErrorRes({ code: 1, reason: "回包异常" });
+                    this.events.emit(`error:${head?.msgId}`, error);
+                    this.events.emit(`error:${head?.module}/${head?.command}`, error);
+                    this.events.emit(`error`, error);
+                    if (error.code === ErrorCode.Login) {
+                        this.onError(new ErrorRes({ code: ErrorCode.Login, reason: "login required" }));
+                    }
+                    else {
+                        this.onError(error);
+                    }
+                    // this.testCount = 0;
+                    // this.limit = this.limit * 5;
+                    return;
+                }
+                if (head?.msgId) {
+                    this.events.emit(head?.msgId, body);
+                    this._requestTasks.delete(head?.msgId);
+                }
+                if (head?.command && head?.module) {
+                    this.events.emit(`${head.module}/${head.command}`, body);
+                }
+            }
+        };
+        _conn.onerror = (e) => {
+            console.error("[websocket] WebSocket error occurred:", e);
+        };
+        _conn.onclose = (e) => {
+            // 给没完成的请求发错误通知
+            this._requestTasks.forEach((v) => {
+                this.events.emit(`error:${v}`, new ErrorRes({
+                    code: 1,
+                    reason: "network error",
+                }));
+            });
+            this._requestTasks = new Set();
+            this._requestStreams.forEach((v) => {
+                this.events.emit(`error:${v}`, new ErrorRes({
+                    code: 1,
+                    reason: "network error",
+                }));
+            });
+            this._requestStreams = new Set();
+            // 正常关闭
+            if (this._retryConnectTime > CONNECT_RETRY_MAX) {
+                // 重试10次失败忽视
+                return;
+            }
+            // 打印详细的关闭原因
+            const closeReason = this.getCloseReason(e.code);
+            const wasClean = e.wasClean ? "clean" : "unclean";
+            console.log(`[websocket] connection closed - code: ${e.code} (${closeReason}), reason: "${e.reason || "N/A"}", wasClean: ${wasClean}, retryCount: ${this._retryConnectTime}`);
+            this._retryConnectTime += 1;
+            this.events.emit("disconnect", e);
+            if (RECONNECT_CODES.includes(e.code)) {
+                const willReconnect = RECONNECT_CODES.includes(e.code);
+                console.log(`[websocket] close code ${e.code} (${closeReason}) is in RECONNECT_CODES, will reconnect: ${willReconnect}`);
+                this.events.emit("close", e);
+                this.reconnect(`onclose_${closeReason}`);
+            }
+            else {
+                console.log(`[websocket] close code ${e.code} (${closeReason}) is NOT in RECONNECT_CODES, no automatic reconnect will be triggered`);
+            }
+            // 鉴权失败
+            if (e.code === WebsocketCloseCode.CloseCodeAuthFailed ||
+                e.code === WebsocketCloseCode.CloseCodeAuthTimeout ||
+                e.code === WebsocketCloseCode.CloseCodeKickOut) {
+                console.log(`[websocket] auth error detected (code: ${e.code}), clearing auth and reconnecting...`);
+                this.clearAuth();
+                this.reconnect("auth_error");
+            }
+            if (e.code === WebsocketCloseCode.CloseCodeKickOut ||
+                e.code === WebsocketCloseCode.CloseCodeUserForbidden) {
+                console.log(`[websocket] user kicked out or forbidden (code: ${e.code}), clearing auth and reconnecting...`);
+                this.clearAuth();
+                // useAuthStore.getState().logout();
+                this.reconnect("logout");
+            }
+        };
+    }
+    async onError(err) {
+        try {
+            if (err.code === ErrorCode.Auth && this.onAuthErr) {
+                this._state = SocketConnectState.Initial;
+                // 鉴权失败回调
+                this._authState = AuthState.Initial;
+                this.auth = null;
+                // this.disconnect('error_auth');
+                this.onAuthErr();
+            }
+            else if (this.errorCount < 5) {
+                if (err.code === -1002) {
+                    // await refreshToken();
+                }
+                this._state = SocketConnectState.Initial;
+                void this.reconnect("onerror");
+                this.errorCount++;
+            }
+        }
+        catch (e) {
+            console.error("[websocket] onError handler failed:", e);
+            // Error is logged but not thrown, to prevent affecting the gateway
+        }
+    }
+    clearAuth() {
+        this._authState = AuthState.Initial;
+        this.auth = null;
+    }
+    startHeartbeat() {
+        if (this._heartHandler) {
+            clearTimeout(this._heartHandler);
+            this._heartHandler = null;
+        }
+        this.heartbeat();
+        this._heartHandler = setTimeout(() => {
+            this.startHeartbeat();
+        }, this.heartbeatTime);
+    }
+    // 发鉴权包
+    sendAuth(oMsgId) {
+        const msgId = oMsgId || uuid();
+        console.log("[websocket]sendAuth", this.auth, msgId);
+        return new Promise((resolve, reject) => {
+            if (!this.auth) {
+                this.onError(new ErrorRes({ code: ErrorCode.Auth, reason: "没有鉴权信息" }));
+                return msgId;
+            }
+            this.send({
+                module: "Stream",
+                command: "Auth",
+                body: this.auth.toBinary(),
+            }, msgId, true);
+            this.on(msgId, (buff) => {
+                if (buff instanceof ErrorRes) {
+                    const err = new ErrorRes({
+                        code: ErrorCode.Auth,
+                        reason: "auth error",
+                    });
+                    console.log("[websocket]sendAuth error", buff);
+                    this.handleAuthError(err?.code);
+                    this.onError(err);
+                    reject(err);
+                    return msgId;
+                }
+                else {
+                    const data = BotAuthBindRes.fromBinary(buff);
+                    console.log("[websocket]sendAuth data", data);
+                    const uid = data?.uid.toString() || "";
+                    // if (data.logined) {
+                    //   useAuthStore.getState().login(uid);
+                    // } else {
+                    //   useAuthStore.getState().logout();
+                    // }
+                    this._connectId = data.conn || null;
+                    if (data?.code) {
+                        const err = new ErrorRes({
+                            code: ErrorCode.Auth,
+                            reason: `auth error${JSON.stringify(data)}`,
+                        });
+                        this.handleAuthError(data?.code);
+                        this.onError(err);
+                        reject(err);
+                        return msgId;
+                    }
+                    const logined = data.uid;
+                    this._state = SocketConnectState.Auth;
+                    this._authState = logined ? AuthState.User : AuthState.Anonymous;
+                    this._retryConnectTime = 0; // 连接成功后重置重连次数
+                    this.startHeartbeat(); // 鉴权成功才开始发心跳包
+                    this._sendQueue.forEach(({ msgId, data }) => {
+                        this.send(data, msgId);
+                    });
+                    this._sendQueue = [];
+                    this.events.emit("connected", { logined, uid: data.uid.toString() });
+                    if (this.onAuthSuccess) {
+                        this.onAuthSuccess();
+                    }
+                    resolve(this._authState);
+                }
+            });
+        });
+    }
+    // 发心跳包
+    heartbeat(oMsgId) {
+        const msgId = oMsgId || uuid();
+        this.send({
+            module: "Stream",
+            command: "Heartbeat",
+            body: new HeartbeatReq({}).toBinary(),
+        }, msgId);
+        let isReceivedHeartbeat = 0;
+        this.on(msgId, (buff) => {
+            isReceivedHeartbeat = 1;
+        });
+        return msgId;
+    }
+    // 发普通包
+    send(params, oMsgId, isAuthPack) {
+        const msgId = oMsgId || uuid();
+        const { body: _, type = MethodKind.Unary, ...rest } = params;
+        if (params.command !== "Heartbeat") {
+            if (type === MethodKind.Unary) {
+                this._requestTasks.add(msgId);
+            }
+            else {
+                this._requestStreams.add(msgId);
+            }
+        }
+        if (this._retryConnectTime >= CONNECT_RETRY_MAX) {
+            this.disconnect("send_retry");
+        }
+        this._retryConnectTime = 0; // 重置重连次数
+        if (!this._conn ||
+            this._state === SocketConnectState.Initial ||
+            this._conn?.readyState !== WebSocket.OPEN) {
+            if (!isAuthPack) {
+                // 非鉴权包才入请求队列
+                this._sendQueue.push({
+                    msgId,
+                    data: params,
+                });
+            }
+            this.create("send");
+            return msgId;
+        }
+        if (!isAuthPack && this._state !== SocketConnectState.Auth) {
+            this._sendQueue.push({
+                msgId,
+                data: params,
+            });
+            return msgId;
+        }
+        const { module, command, body } = params;
+        if (!body) {
+            return msgId;
+        }
+        const data = {
+            head: {
+                frameType: 1, // 包体数据类型，0=text, 1=pb
+                msgType: 0, // 0=上行req，1=上行req的回包rsp，2=下行的push，3=下行push的回包（ack）
+                msgId: msgId,
+                module,
+                command,
+                reserved: {},
+            },
+            body,
+        };
+        console.log("[websocket]send ", new Date().toLocaleTimeString(), JSON.stringify({
+            command,
+            module,
+            _connectId: this._connectId,
+            msgId,
+        }));
+        try {
+            this._conn.send(new StreamMsg(data).toBinary());
+        }
+        catch (e) {
+            if (!isAuthPack) {
+                // 非鉴权包才加入请求队列
+                this._sendQueue.push({
+                    msgId,
+                    data: params,
+                });
+            }
+            this.create("send catch");
+        }
+        return msgId;
+    }
+    // 主动断连
+    disconnect(type, onClose) {
+        const readyState = this._conn?.readyState;
+        const stateNames = {
+            [WebSocket.CONNECTING]: "CONNECTING",
+            [WebSocket.OPEN]: "OPEN",
+            [WebSocket.CLOSING]: "CLOSING",
+            [WebSocket.CLOSED]: "CLOSED",
+        };
+        console.log(`[websocket] disconnect initiated - reason: "${type}", currentState: ${this._state}, readyState: ${stateNames[readyState ?? -1] || readyState}`);
+        if (!this._conn || this._state === SocketConnectState.Initial) {
+            console.log(`[websocket] disconnect skipped - no active connection`);
+            return;
+        }
+        if (this._conn?.readyState !== WebSocket.CLOSED) {
+            try {
+                this._conn.onclose = (e) => {
+                    console.log(`[websocket] connection closed by disconnect() - code: ${e.code}, reason: "${e.reason || "N/A"}"`);
+                    this._conn = null;
+                    setTimeout(() => {
+                        onClose?.();
+                    }, 1000);
+                };
+                this._conn.close();
+            }
+            catch (e) {
+                console.error("[websocket] disconnect error during close():", e);
+            }
+        }
+        else {
+            console.log(`[websocket] disconnect skipped - connection already closed (readyState: ${readyState})`);
+        }
+        this.clearConnection();
+    }
+    // 重连
+    async reconnect(scene) {
+        console.log(`[websocket] starting reconnect sequence - trigger: "${scene}", attempt: ${this._retryConnectTime + 1}/${CONNECT_RETRY_MAX}`);
+        this.disconnect("connect", async () => {
+            try {
+                console.log(`[websocket] creating new connection after disconnect...`);
+                await this.create("reconnect");
+                console.log(`[websocket] reconnect successful`);
+                this.events.emit("reconnect");
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                console.error(`[websocket] reconnect failed: ${errorMsg}`);
+                // Error is logged but not thrown, to prevent affecting the gateway
+            }
+        });
+    }
+    // 清除连接
+    clearConnection() {
+        this._conn = null;
+        this._connectId = null;
+        this.events.off("close");
+        this.events.off("open");
+        this.events.off("disconnect");
+        this.events.off("message");
+        // this.events.off('auth-error');
+        // this.events = new Event();
+    }
+    /**
+     * 获取 WebSocket 关闭代码的文字说明
+     */
+    getCloseReason(code) {
+        const reasons = {
+            1000: "normal closure",
+            1001: "going away",
+            1002: "protocol error",
+            1003: "unsupported data",
+            1005: "no status received",
+            1006: "abnormal closure",
+            1007: "invalid frame payload data",
+            1008: "policy violation",
+            1009: "message too big",
+            1010: "mandatory extension",
+            1011: "internal server error",
+            1012: "service restart",
+            1013: "try again later",
+            1014: "bad gateway",
+            1015: "TLS handshake",
+            4001: "auth failed",
+            4002: "auth timeout",
+            4003: "heartbeat timeout",
+            4004: "same user reconnect",
+            4005: "kicked out",
+            4006: "user forbidden",
+            4007: "parse message failed",
+            4008: "server restart",
+        };
+        return reasons[code] || `unknown code ${code}`;
+    }
+    handleAuthError(code) {
+        console.log("[websocket]handleAuthError", code);
+        if ([
+            AuthSocketError.AuthCodeBanned,
+            AuthSocketError.AuthCodeExpired,
+            AuthSocketError.AuthCodeFail,
+            AuthSocketError.AuthCodeNotActivated,
+        ].includes(code)) {
+            this.events.emit("auth-error", { code });
+            this.clearAuth();
+            this.disconnect("auth_error");
+        }
+    }
+    on(key, fn) {
+        this.events.on(key, fn);
+    }
+    emit(key, args) {
+        this.events.emit(key, args);
+    }
+}
+export let Socket;
+export { _Socket };
+export function getSocket() {
+    if (!Socket) {
+        Socket = new _Socket();
+    }
+    return Socket;
+}
+export function setSocket(socket) {
+    Socket = socket;
+}
+//# sourceMappingURL=index.js.map

package/dist/src/websocket/service.d.ts

@@ -0,0 +1,36 @@
+export declare const BotMsgSocketClient: import("./connect").PromiseClient<{
+    readonly typeName: "step.capy.botmsg.BotMsg";
+    readonly methods: {
+        readonly fetchMessages: {
+            readonly name: "FetchMessages";
+            readonly I: typeof import("../proto/capy/botmsg/botmsg_pb").FetchMessagesRequest;
+            readonly O: typeof import("../proto/capy/botmsg/botmsg_pb").FetchMessagesResponse;
+            readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+        };
+        readonly hasNewMessages: {
+            readonly name: "HasNewMessages";
+            readonly I: typeof import("../proto/capy/botmsg/botmsg_pb").HasNewMessagesRequest;
+            readonly O: typeof import("../proto/capy/botmsg/botmsg_pb").HasNewMessagesResponse;
+            readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+        };
+        readonly sendMessages: {
+            readonly name: "SendMessages";
+            readonly I: typeof import("../proto/capy/botmsg/botmsg_pb").SendMessagesRequest;
+            readonly O: typeof import("../proto/capy/botmsg/botmsg_pb").SendMessagesResponse;
+            readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+        };
+        readonly pushMessages: {
+            readonly name: "PushMessages";
+            readonly I: typeof import("../proto/capy/botmsg/botmsg_pb").PushMessagesRequest;
+            readonly O: typeof import("../proto/capy/botmsg/botmsg_pb").PushMessagesResponse;
+            readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+        };
+        readonly checkBotOnline: {
+            readonly name: "CheckBotOnline";
+            readonly I: typeof import("../proto/capy/botmsg/botmsg_pb").CheckBotOnlineRequest;
+            readonly O: typeof import("../proto/capy/botmsg/botmsg_pb").CheckBotOnlineResponse;
+            readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+        };
+    };
+}>;
+//# sourceMappingURL=service.d.ts.map

package/dist/src/websocket/service.js

@@ -0,0 +1,4 @@
+import { createSocketConnect } from './connect';
+import { BotMsg } from '../proto/capy/botmsg/botmsg_connect';
+export const BotMsgSocketClient = createSocketConnect('BotMsg', BotMsg);
+//# sourceMappingURL=service.js.map

package/dist/src/websocket/stream.d.ts

@@ -0,0 +1,10 @@
+import type { SocketCallbacks } from './connect';
+type StreamFuncs<I, O> = {
+    start: (cb?: SocketCallbacks<O>['onStart']) => StreamFuncs<I, O>;
+    on: (cb?: SocketCallbacks<O>['onData']) => StreamFuncs<I, O>;
+    do: () => Promise<O>;
+    error: (cb?: SocketCallbacks<O>['onError']) => StreamFuncs<I, O>;
+};
+export declare const stream: <I, O>(method: (req: I, callbacks?: SocketCallbacks<O>, once?: boolean) => Promise<O>, payload: I) => StreamFuncs<I, O>;
+export {};
+//# sourceMappingURL=stream.d.ts.map