openclaw-stepfun 0.2.2

package/dist/src/client.js

@@ -0,0 +1,206 @@
+import { setSocket, _Socket, SocketConnectState, } from "./websocket/index.js";
+import { ErrorRes } from "./websocket/streamConnect.js";
+import { BotMsgSocketClient } from "./websocket/service.js";
+import { ChatMessage, ChatMessageContent, MessageType, BotType, SendMessagesRequest, PushMessagesResponse, } from "./proto/capy/botmsg/botmsg_pb.js";
+/**
+ * Wrapper class that adapts getSocket() to the StepfunWSClient interface.
+ * Maintains backward compatibility with existing code.
+ */
+class StepfunWSClientWrapper {
+    socket;
+    account;
+    onMessage;
+    onError;
+    onClose;
+    isConnectedFlag = false;
+    constructor(socket, account) {
+        this.socket = socket;
+        this.account = account;
+        this.setupEventHandlers();
+    }
+    setupEventHandlers() {
+        // Listen for connection events
+        this.socket.on("connected", () => {
+            this.isConnectedFlag = true;
+        });
+        this.socket.on("disconnect", () => {
+            this.isConnectedFlag = false;
+        });
+        this.socket.on("close", () => {
+            this.isConnectedFlag = false;
+            this.onClose?.();
+        });
+        // Listen for incoming BotMsg messages
+        // Module: BotMsg, Command: NewMessage (for push messages)
+        this.socket.on("BotMsg/PushMessages", (data) => {
+            try {
+                if (data instanceof ErrorRes) {
+                    throw new Error(data.reason);
+                }
+                const message = PushMessagesResponse.fromBinary(data).messages;
+                // console.debug("BotMsg/PushMessages---fromBinary", message);
+                if (!message) {
+                    throw new Error("message is empty");
+                }
+                const inboundMessage = this.convertToInboundMessage(message);
+                this.onMessage?.(inboundMessage);
+            }
+            catch (err) {
+                console.error("[stepfun] Failed to parse incoming message:", err);
+                this.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        // Listen for errors
+        this.socket.on("error", (error) => {
+            const errorMsg = error instanceof Error ? error.message : JSON.stringify(error);
+            this.onError?.(new Error(errorMsg));
+        });
+    }
+    convertToInboundMessage(message) {
+        // Handle timestamp - if createdAt is 0 or invalid, use current time
+        let timestamp;
+        if (message.createdAt) {
+            const parsed = new Date(message.createdAt).getTime();
+            // Check for invalid date (NaN) or zero/negative timestamps that indicate epoch issues
+            timestamp = !isNaN(parsed) && parsed > 0 ? parsed : Date.now();
+        }
+        else {
+            timestamp = Date.now();
+        }
+        return {
+            chatSessionId: message.sessionId,
+            type: "text",
+            appId: this.account.config.appId || "",
+            messageId: message.msgId,
+            userId: message.senderUid,
+            userName: undefined,
+            content: message.content?.content || "",
+            timestamp,
+        };
+    }
+    /**
+     * Connect to the gateway.
+     * Note: Errors are handled via onError callback, not thrown, to ensure
+     * the OpenClaw gateway is not affected by connection failures.
+     */
+    connect(handlers) {
+        this.onMessage = handlers.onMessage;
+        this.onError = handlers.onError;
+        this.onClose = handlers.onClose;
+        // Set auth credentials from config
+        const token = this.account.config.appToken;
+        const appId = this.account.config.appId;
+        if (!token || !appId) {
+            // Report error via callback instead of throwing, to avoid affecting the gateway
+            const error = new Error("Stepfun appId and appToken are required");
+            console.error("[stepfun] Configuration error:", error.message);
+            this.onError?.(error);
+            return;
+        }
+        this.socket.setAuth(token, appId);
+        // Create connection
+        this.socket
+            .create("stepfun connect")
+            .then(() => {
+            console.log("[stepfun] WebSocket connection initiated");
+        })
+            .catch((err) => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            console.error("[stepfun] Connection failed:", error.message);
+            this.onError?.(error);
+        });
+    }
+    /**
+     * Send a message to the gateway.
+     * Converts JSON message to Protobuf format.
+     */
+    async send(data) {
+        const message = data;
+        // Get appId from config
+        const appId = this.account.config.appId;
+        if (!appId) {
+            throw new Error("Stepfun appId is required to send messages");
+        }
+        // Build Protobuf message
+        const chatMessage = new ChatMessage({
+            appId: appId,
+            sessionId: message.chatSessionId,
+            senderUid: "0", // Robot sends as 0
+            msgType: MessageType.MessageType_BOT_MSG,
+            botType: BotType.BotType_OPENCLAW,
+            content: new ChatMessageContent({
+                content: message.content,
+            }),
+        });
+        // console.debug("send-----", chatMessage);
+        const request = new SendMessagesRequest({
+            message: chatMessage,
+        });
+        // Send via BotMsg service
+        await BotMsgSocketClient.sendMessages(request);
+    }
+    /**
+     * Close the connection.
+     */
+    close() {
+        this.socket.disconnect("client close");
+        this.isConnectedFlag = false;
+    }
+    /**
+     * Check if connected.
+     */
+    isConnected() {
+        return (this.isConnectedFlag && this.socket._state === SocketConnectState.Auth);
+    }
+}
+// Global WebSocket client instance
+let wsClient = null;
+let currentAccountConfig = null;
+/**
+ * Check if account config has changed (appId or appToken).
+ */
+function hasAccountConfigChanged(newAccount) {
+    if (!currentAccountConfig) {
+        return true;
+    }
+    return (currentAccountConfig.config.appId !== newAccount.config.appId ||
+        currentAccountConfig.config.appToken !== newAccount.config.appToken);
+}
+/**
+ * Get or create WebSocket client.
+ * If account config (appId or appToken) has changed, recreates the client with new credentials.
+ */
+export function getStepfunWSClient(account) {
+    // If config has changed, close existing client and create new one
+    if (wsClient && hasAccountConfigChanged(account)) {
+        console.log("[stepfun] Account config changed (appId or appToken), recreating WebSocket client...");
+        closeStepfunWSClient();
+    }
+    if (!wsClient) {
+        // Create socket with ignoreCreate to prevent auto-connection before auth is set
+        const socket = new _Socket({ ignoreCreate: true });
+        // Set auth credentials before any connection attempt
+        const token = account.config.appToken;
+        const appId = account.config.appId;
+        // console.debug("----appId----", appId, token);
+        if (token && appId) {
+            socket.setAuth(token, appId);
+        }
+        // Set the socket so getSocket() returns this instance
+        setSocket(socket);
+        wsClient = new StepfunWSClientWrapper(socket, account);
+        currentAccountConfig = account;
+    }
+    return wsClient;
+}
+/**
+ * Close and clear WebSocket client.
+ */
+export function closeStepfunWSClient() {
+    if (wsClient) {
+        wsClient.close();
+        wsClient = null;
+    }
+    currentAccountConfig = null;
+}
+//# sourceMappingURL=client.js.map

package/dist/src/monitor.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+export type MonitorStepfunOpts = {
+    config?: OpenClawConfig;
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    accountId?: string;
+};
+/**
+ * Main entry: start monitoring for all enabled accounts.
+ * Note: This function should never throw, as plugin failures should not
+ * affect the OpenClaw gateway. Errors are logged and the function returns
+ * normally even if connections fail.
+ */
+export declare function monitorStepfunProvider(opts?: MonitorStepfunOpts): Promise<void>;
+/**
+ * Stop monitoring.
+ */
+export declare function stopStepfunMonitor(): void;
+//# sourceMappingURL=monitor.d.ts.map

package/dist/src/monitor.js

@@ -0,0 +1,153 @@
+import { resolveStepfunAccount, listEnabledStepfunAccounts, } from "./accounts.js";
+import { handleStepfunMessage } from "./bot.js";
+import { getStepfunWSClient, closeStepfunWSClient } from "./client.js";
+/**
+ * Monitor a single Stepfun account.
+ * Note: This function should never reject, as WebSocket connection failures
+ * should not affect the OpenClaw gateway. Errors are logged and the connection
+ * will be retried automatically.
+ */
+async function monitorSingleAccount(params) {
+    const { cfg, account, runtime, abortSignal } = params;
+    const { accountId } = account;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    log(`stepfun[${accountId}]: starting WebSocket connection...`);
+    // Check if account is properly configured before attempting connection
+    if (!account.configured) {
+        log(`stepfun[${accountId}]: account not configured (missing appId or appToken), skipping connection`);
+        return;
+    }
+    const wsClient = getStepfunWSClient(account);
+    return new Promise((resolve) => {
+        const cleanup = () => {
+            closeStepfunWSClient();
+        };
+        const handleAbort = () => {
+            log(`stepfun[${accountId}]: abort signal received, stopping`);
+            cleanup();
+            resolve();
+        };
+        if (abortSignal?.aborted) {
+            cleanup();
+            resolve();
+            return;
+        }
+        abortSignal?.addEventListener("abort", handleAbort, { once: true });
+        try {
+            wsClient.connect({
+                onMessage: async (data) => {
+                    try {
+                        // Parse incoming message from gateway
+                        const message = data;
+                        // console.debug("message-----", message);
+                        // Validate message format
+                        if (!message.messageId || !message.content) {
+                            log(`stepfun[${accountId}]: invalid message format, skipping`);
+                            return;
+                        }
+                        // Handle the message
+                        await handleStepfunMessage({
+                            cfg,
+                            message,
+                            runtime,
+                            accountId,
+                        });
+                    }
+                    catch (err) {
+                        error(`stepfun[${accountId}]: error handling message: ${String(err)}`);
+                    }
+                },
+                onError: (err) => {
+                    const errorMsg = err instanceof Error ? err.message : JSON.stringify(err);
+                    error(`stepfun[${accountId}]: WebSocket error: ${errorMsg}`);
+                    // Don't reject - let the WebSocket client handle reconnection
+                },
+                onClose: () => {
+                    if (abortSignal?.aborted) {
+                        log(`stepfun[${accountId}]: connection closed (aborted)`);
+                        cleanup();
+                        resolve();
+                    }
+                    else {
+                        log(`stepfun[${accountId}]: connection closed, will attempt reconnect`);
+                        // Don't resolve here - let the WebSocket client handle reconnection
+                    }
+                },
+            });
+            log(`stepfun[${accountId}]: WebSocket client started`);
+        }
+        catch (err) {
+            // Log the error but don't reject - this ensures the gateway continues running
+            // even if the initial connection fails. The WebSocket client will retry.
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            error(`stepfun[${accountId}]: failed to start WebSocket client: ${errorMsg}`);
+            error(`stepfun[${accountId}]: connection will be retried automatically when configured`);
+            // Clean up but resolve (not reject) to avoid affecting the gateway
+            cleanup();
+            abortSignal?.removeEventListener("abort", handleAbort);
+            resolve();
+        }
+    });
+}
+/**
+ * Main entry: start monitoring for all enabled accounts.
+ * Note: This function should never throw, as plugin failures should not
+ * affect the OpenClaw gateway. Errors are logged and the function returns
+ * normally even if connections fail.
+ */
+export async function monitorStepfunProvider(opts = {}) {
+    const cfg = opts.config;
+    if (!cfg) {
+        console.error("[stepfun] Config is required for Stepfun monitor");
+        return;
+    }
+    const log = opts.runtime?.log ?? console.log;
+    const error = opts.runtime?.error ?? console.error;
+    // If accountId is specified, only monitor that account
+    if (opts.accountId) {
+        const account = resolveStepfunAccount({ cfg, accountId: opts.accountId });
+        if (!account.enabled) {
+            log(`[stepfun] Account "${opts.accountId}" is disabled, skipping`);
+            return;
+        }
+        if (!account.configured) {
+            log(`[stepfun] Account "${opts.accountId}" is not configured (missing appId or appToken), skipping`);
+            return;
+        }
+        return monitorSingleAccount({
+            cfg,
+            account,
+            runtime: opts.runtime,
+            abortSignal: opts.abortSignal,
+        });
+    }
+    // Otherwise, start all enabled accounts
+    const accounts = listEnabledStepfunAccounts(cfg);
+    if (accounts.length === 0) {
+        log("[stepfun] No enabled and configured Stepfun accounts found");
+        return;
+    }
+    log(`[stepfun] Starting ${accounts.length} account(s): ${accounts.map((a) => a.accountId).join(", ")}`);
+    // Start all accounts in parallel, with error isolation
+    // Use Promise.allSettled to ensure one account's failure doesn't affect others
+    const results = await Promise.allSettled(accounts.map((account) => monitorSingleAccount({
+        cfg,
+        account,
+        runtime: opts.runtime,
+        abortSignal: opts.abortSignal,
+    })));
+    // Log any failures but don't throw
+    results.forEach((result, index) => {
+        if (result.status === "rejected") {
+            error(`[stepfun] Account ${accounts[index]?.accountId} failed: ${result.reason}`);
+        }
+    });
+}
+/**
+ * Stop monitoring.
+ */
+export function stopStepfunMonitor() {
+    closeStepfunWSClient();
+}
+//# sourceMappingURL=monitor.js.map

package/dist/src/proto/capy/botauth/auth_common_pb.d.ts

@@ -0,0 +1,82 @@
+// @generated by protoc-gen-es v1.8.0 with parameter "target=js+dts"
+// @generated from file capy/botauth/auth_common.proto (package step.capy.botauth, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3 } from "@bufbuild/protobuf";
+
+/**
+ * @generated from enum step.capy.botauth.BotAccountStatus
+ */
+export declare enum BotAccountStatus {
+  /**
+   * @generated from enum value: Normal = 0;
+   */
+  Normal = 0,
+
+  /**
+   * @generated from enum value: Disabled = 1;
+   */
+  Disabled = 1,
+
+  /**
+   * @generated from enum value: Deleted = 100;
+   */
+  Deleted = 100,
+}
+
+/**
+ * @generated from message step.capy.botauth.BotAccount
+ */
+export declare class BotAccount extends Message<BotAccount> {
+  /**
+   * @generated from field: string app_id = 1;
+   */
+  appId: string;
+
+  /**
+   * @generated from field: string uid = 2;
+   */
+  uid: string;
+
+  /**
+   * @generated from field: string token = 3;
+   */
+  token: string;
+
+  /**
+   * @generated from field: string name = 4;
+   */
+  name: string;
+
+  /**
+   * @generated from field: step.capy.botauth.BotAccountStatus state = 5;
+   */
+  state: BotAccountStatus;
+
+  /**
+   * @generated from field: string created_at = 6;
+   */
+  createdAt: string;
+
+  /**
+   * @generated from field: string updated_at = 7;
+   */
+  updatedAt: string;
+
+  constructor(data?: PartialMessage<BotAccount>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "step.capy.botauth.BotAccount";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BotAccount;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BotAccount;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BotAccount;
+
+  static equals(a: BotAccount | PlainMessage<BotAccount> | undefined, b: BotAccount | PlainMessage<BotAccount> | undefined): boolean;
+}
+

package/dist/src/proto/capy/botauth/auth_common_pb.js

@@ -0,0 +1,35 @@
+// @generated by protoc-gen-es v1.8.0 with parameter "target=js+dts"
+// @generated from file capy/botauth/auth_common.proto (package step.capy.botauth, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { proto3 } from "@bufbuild/protobuf";
+
+/**
+ * @generated from enum step.capy.botauth.BotAccountStatus
+ */
+export const BotAccountStatus = /*@__PURE__*/ proto3.makeEnum(
+  "step.capy.botauth.BotAccountStatus",
+  [
+    {no: 0, name: "Normal"},
+    {no: 1, name: "Disabled"},
+    {no: 100, name: "Deleted"},
+  ],
+);
+
+/**
+ * @generated from message step.capy.botauth.BotAccount
+ */
+export const BotAccount = /*@__PURE__*/ proto3.makeMessageType(
+  "step.capy.botauth.BotAccount",
+  () => [
+    { no: 1, name: "app_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "uid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "state", kind: "enum", T: proto3.getEnumType(BotAccountStatus) },
+    { no: 6, name: "created_at", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 7, name: "updated_at", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ],
+);
+

package/dist/src/proto/capy/botauth/botauth_connect.d.ts

@@ -0,0 +1,118 @@
+// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=js+dts"
+// @generated from file capy/botauth/botauth.proto (package step.capy.botauth, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { BotHeartbeatReq, BotHeartbeatRes, BotLoginReq, BotLoginRes, BotLogoutReq, BotLogoutRes, GetUserBotAccountReq, GetUserBotAccountRes, HeartbeatReq, HeartbeatRes, LoginReq, LoginRes, LogoutReq, LogoutRes, QueryBotReq, QueryBotRes, QueryBotSessionReq, QueryBotSessionRes, QuerySessionReq, QuerySessionRes, QueryUserReq, QueryUserRes } from "./botauth_pb.js";
+import { MethodKind } from "@bufbuild/protobuf";
+
+/**
+ * @generated from service step.capy.botauth.Auth
+ */
+export declare const Auth: {
+  readonly typeName: "step.capy.botauth.Auth",
+  readonly methods: {
+    /**
+     * @generated from rpc step.capy.botauth.Auth.Login
+     */
+    readonly login: {
+      readonly name: "Login",
+      readonly I: typeof LoginReq,
+      readonly O: typeof LoginRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.Logout
+     */
+    readonly logout: {
+      readonly name: "Logout",
+      readonly I: typeof LogoutReq,
+      readonly O: typeof LogoutRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.Heartbeat
+     */
+    readonly heartbeat: {
+      readonly name: "Heartbeat",
+      readonly I: typeof HeartbeatReq,
+      readonly O: typeof HeartbeatRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.BotLogin
+     */
+    readonly botLogin: {
+      readonly name: "BotLogin",
+      readonly I: typeof BotLoginReq,
+      readonly O: typeof BotLoginRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.BotLogout
+     */
+    readonly botLogout: {
+      readonly name: "BotLogout",
+      readonly I: typeof BotLogoutReq,
+      readonly O: typeof BotLogoutRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.BotHeartbeat
+     */
+    readonly botHeartbeat: {
+      readonly name: "BotHeartbeat",
+      readonly I: typeof BotHeartbeatReq,
+      readonly O: typeof BotHeartbeatRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.QuerySession
+     */
+    readonly querySession: {
+      readonly name: "QuerySession",
+      readonly I: typeof QuerySessionReq,
+      readonly O: typeof QuerySessionRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.QueryUser
+     */
+    readonly queryUser: {
+      readonly name: "QueryUser",
+      readonly I: typeof QueryUserReq,
+      readonly O: typeof QueryUserRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.QueryBotSession
+     */
+    readonly queryBotSession: {
+      readonly name: "QueryBotSession",
+      readonly I: typeof QueryBotSessionReq,
+      readonly O: typeof QueryBotSessionRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc step.capy.botauth.Auth.QueryBot
+     */
+    readonly queryBot: {
+      readonly name: "QueryBot",
+      readonly I: typeof QueryBotReq,
+      readonly O: typeof QueryBotRes,
+      readonly kind: MethodKind.Unary,
+    },
+    /**
+     * 查询数据库
+     *
+     * @generated from rpc step.capy.botauth.Auth.GetUserBotAccount
+     */
+    readonly getUserBotAccount: {
+      readonly name: "GetUserBotAccount",
+      readonly I: typeof GetUserBotAccountReq,
+      readonly O: typeof GetUserBotAccountRes,
+      readonly kind: MethodKind.Unary,
+    },
+  }
+};
+