@wecode-ai/weibo-openclaw-plugin 1.0.0 → 1.0.1

package/src/client.ts

@@ -1,435 +0,0 @@
-import { createRequire } from "module";
-import WebSocket from "ws";
-import type { ResolvedWeiboAccount, WeiboRuntimeStatusPatch } from "./types.js";
-
-// Read version from package.json
-const require = createRequire(import.meta.url);
-const { version: PLUGIN_VERSION } = require("../package.json") as { version: string };
-import {
-  getValidToken,
-  clearTokenCache,
-  formatWeiboTokenFetchErrorMessage,
-  isRetryableWeiboTokenFetchError,
-} from "./token.js";
-import { getWeiboConnectionFingerprint } from "./fingerprint.js";
-
-export type WebSocketMessageHandler = (data: unknown) => void;
-export type WebSocketErrorHandler = (error: Error) => void;
-export type WebSocketCloseHandler = (code: number, reason: string) => void;
-export type WebSocketOpenHandler = () => void;
-export type WebSocketStatusHandler = (patch: WeiboRuntimeStatusPatch) => void;
-
-// Ping interval: 30 seconds
-const PING_INTERVAL_MS = 30_000;
-// Initial reconnect delay: 1 second
-const INITIAL_RECONNECT_DELAY_MS = 1_000;
-// Maximum reconnect delay: 60 seconds
-const MAX_RECONNECT_DELAY_MS = 60_000;
-// Maximum reconnect attempts (0 = infinite)
-const MAX_RECONNECT_ATTEMPTS = 0;
-
-export type WeiboClientOptions = {
-  onMessage?: WebSocketMessageHandler;
-  onError?: WebSocketErrorHandler;
-  onClose?: WebSocketCloseHandler;
-  onOpen?: WebSocketOpenHandler;
-  onStatus?: WebSocketStatusHandler;
-  autoReconnect?: boolean;
-  maxReconnectAttempts?: number;
-};
-
-function isRetryableConnectError(err: unknown): boolean {
-  const retryableTokenError = isRetryableWeiboTokenFetchError(err);
-  if (retryableTokenError !== null) {
-    return retryableTokenError;
-  }
-
-  if (err instanceof Error) {
-    const message = err.message.toLowerCase();
-    if (message.includes("not configured")) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export class WeiboWebSocketClient {
-  private ws: WebSocket | null = null;
-  private messageHandler: WebSocketMessageHandler | null = null;
-  private errorHandler: WebSocketErrorHandler | null = null;
-  private closeHandler: WebSocketCloseHandler | null = null;
-  private openHandler: WebSocketOpenHandler | null = null;
-  private statusHandler: WebSocketStatusHandler | null = null;
-
-  // Heartbeat
-  private pingInterval: NodeJS.Timeout | null = null;
-  private lastPongTime: number = 0;
-  private readonly PING_TIMEOUT_MS = 10_000;
-
-  // Reconnection
-  private reconnectAttempts = 0;
-  private reconnectTimeout: NodeJS.Timeout | null = null;
-  private isConnecting = false;
-  private shouldReconnect = true;
-  private autoReconnect: boolean;
-  private maxReconnectAttempts: number;
-
-  constructor(
-    private account: ResolvedWeiboAccount,
-    private options: WeiboClientOptions = {}
-  ) {
-    this.autoReconnect = options.autoReconnect ?? true;
-    this.maxReconnectAttempts = options.maxReconnectAttempts ?? MAX_RECONNECT_ATTEMPTS;
-    this.messageHandler = options.onMessage ?? null;
-    this.errorHandler = options.onError ?? null;
-    this.closeHandler = options.onClose ?? null;
-    this.openHandler = options.onOpen ?? null;
-    this.statusHandler = options.onStatus ?? null;
-  }
-
-  private emitStatus(patch: WeiboRuntimeStatusPatch): void {
-    this.statusHandler?.(patch);
-  }
-
-  async connect(): Promise<void> {
-    if (this.isConnecting || this.ws?.readyState === WebSocket.OPEN) {
-      return;
-    }
-
-    this.isConnecting = true;
-    this.shouldReconnect = true;
-    this.emitStatus({
-      running: true,
-      connected: false,
-      connectionState: "connecting",
-      nextRetryAt: null,
-      lastError: null,
-    });
-
-    const { wsEndpoint, appId, tokenEndpoint } = this.account;
-
-    if (!wsEndpoint) {
-      this.isConnecting = false;
-      throw new Error(
-        `WebSocket endpoint not configured for account "${this.account.accountId}"`
-      );
-    }
-
-    if (!appId) {
-      this.isConnecting = false;
-      throw new Error(
-        `App ID not configured for account "${this.account.accountId}"`
-      );
-    }
-
-    try {
-      // Fetch token from API
-      const token = await getValidToken(this.account, tokenEndpoint);
-
-      const url = new URL(wsEndpoint);
-      url.searchParams.set("app_id", appId);
-      url.searchParams.set("token", token);
-      url.searchParams.set("version", PLUGIN_VERSION);
-
-      this.ws = new WebSocket(url.toString());
-
-      this.ws.on("open", () => {
-        this.isConnecting = false;
-        this.reconnectAttempts = 0;
-        this.lastPongTime = Date.now();
-        this.startHeartbeat();
-        this.emitStatus({
-          running: true,
-          connected: true,
-          connectionState: "connected",
-          reconnectAttempts: 0,
-          nextRetryAt: null,
-          lastConnectedAt: Date.now(),
-          lastError: null,
-        });
-        this.openHandler?.();
-      });
-
-      this.ws.on("message", (data) => {
-        try {
-          const text = data.toString();
-
-          // Handle pong response
-          if (text === "pong" || text === "{\"type\":\"pong\"}") {
-            this.lastPongTime = Date.now();
-            return;
-          }
-
-          const parsed = JSON.parse(text);
-          this.messageHandler?.(parsed);
-        } catch {
-          // Ignore invalid JSON
-        }
-      });
-
-      this.ws.on("error", (err) => {
-        this.emitStatus({
-          running: true,
-          connected: false,
-          connectionState: "error",
-          lastError: err.message,
-        });
-        this.errorHandler?.(err);
-      });
-
-      this.ws.on("close", (code, reason) => {
-        this.isConnecting = false;
-        this.stopHeartbeat();
-        const reasonStr = reason.toString() || "unknown";
-        if (code === 4002 || /invalid token/i.test(reasonStr)) {
-          clearTokenCache(this.account.accountId);
-        }
-        this.emitStatus({
-          running: this.shouldReconnect,
-          connected: false,
-          connectionState:
-            this.shouldReconnect && this.autoReconnect ? "error" : "stopped",
-          lastDisconnect: {
-            code,
-            reason: reasonStr,
-            at: Date.now(),
-          },
-        });
-        this.closeHandler?.(code, reasonStr);
-
-        // Auto reconnect if enabled
-        if (this.shouldReconnect && this.autoReconnect) {
-          this.scheduleReconnect(reasonStr);
-        }
-      });
-
-      this.ws.on("pong", () => {
-        this.lastPongTime = Date.now();
-      });
-    } catch (err) {
-      this.isConnecting = false;
-      const message =
-        formatWeiboTokenFetchErrorMessage(err)
-        ?? (err instanceof Error ? err.message : String(err));
-      this.emitStatus({
-        running: true,
-        connected: false,
-        connectionState: "error",
-        lastError: message,
-      });
-      // Schedule reconnect on connection failure
-      if (this.shouldReconnect && this.autoReconnect && isRetryableConnectError(err)) {
-        this.scheduleReconnect(message);
-      }
-      throw err;
-    }
-  }
-
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-
-    this.pingInterval = setInterval(() => {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        // Check if we received pong recently
-        const timeSinceLastPong = Date.now() - this.lastPongTime;
-        if (timeSinceLastPong > PING_INTERVAL_MS + this.PING_TIMEOUT_MS) {
-          // Connection may be dead, close and reconnect
-          console.warn(
-            `weibo[${this.account.accountId}]: pong timeout, closing connection`
-          );
-          this.ws.terminate();
-          return;
-        }
-
-        // Send ping
-        try {
-          this.ws.send(JSON.stringify({ type: "ping" }));
-        } catch (err) {
-          console.error(
-            `weibo[${this.account.accountId}]: failed to send ping:`,
-            err
-          );
-        }
-      }
-    }, PING_INTERVAL_MS);
-  }
-
-  private stopHeartbeat(): void {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
-    }
-  }
-
-  private scheduleReconnect(lastError?: string): void {
-    if (this.reconnectTimeout) {
-      return;
-    }
-
-    // Check max reconnect attempts
-    if (
-      this.maxReconnectAttempts > 0 &&
-      this.reconnectAttempts >= this.maxReconnectAttempts
-    ) {
-      console.error(
-        `weibo[${this.account.accountId}]: max reconnect attempts reached`
-      );
-      return;
-    }
-
-    // Calculate delay with exponential backoff
-    const delay = Math.min(
-      INITIAL_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempts),
-      MAX_RECONNECT_DELAY_MS
-    );
-
-    this.reconnectAttempts++;
-    this.emitStatus({
-      running: true,
-      connected: false,
-      connectionState: "backoff",
-      reconnectAttempts: this.reconnectAttempts,
-      nextRetryAt: Date.now() + delay,
-      lastError: lastError ?? null,
-    });
-
-    console.log(
-      `weibo[${this.account.accountId}]: reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`
-    );
-
-    this.reconnectTimeout = setTimeout(() => {
-      this.reconnectTimeout = null;
-      this.connect().catch((err) => {
-        console.error(
-          `weibo[${this.account.accountId}]: reconnect failed:`,
-          err
-        );
-      });
-    }, delay);
-  }
-
-  onMessage(handler: WebSocketMessageHandler): void {
-    this.messageHandler = handler;
-  }
-
-  onError(handler: WebSocketErrorHandler): void {
-    this.errorHandler = handler;
-  }
-
-  onClose(handler: WebSocketCloseHandler): void {
-    this.closeHandler = handler;
-  }
-
-  onOpen(handler: WebSocketOpenHandler): void {
-    this.openHandler = handler;
-  }
-
-  onStatus(handler: WebSocketStatusHandler): void {
-    this.statusHandler = handler;
-  }
-
-  send(data: unknown): boolean {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      try {
-        this.ws.send(JSON.stringify(data));
-        return true;
-      } catch (err) {
-        console.error(
-          `weibo[${this.account.accountId}]: failed to send message:`,
-          err
-        );
-        return false;
-      }
-    }
-    return false;
-  }
-
-  isConnected(): boolean {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-
-  close(): void {
-    this.shouldReconnect = false;
-    this.stopHeartbeat();
-
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout);
-      this.reconnectTimeout = null;
-    }
-
-    this.ws?.close();
-    this.ws = null;
-    this.emitStatus({
-      running: false,
-      connected: false,
-      connectionState: "stopped",
-      nextRetryAt: null,
-      lastStopAt: Date.now(),
-    });
-  }
-}
-
-type ClientCacheEntry = {
-  client: WeiboWebSocketClient;
-  fingerprint: string;
-};
-
-function applyOptions(client: WeiboWebSocketClient, options?: WeiboClientOptions): void {
-  if (!options) {
-    return;
-  }
-  if (options.onMessage) {
-    client.onMessage(options.onMessage);
-  }
-  if (options.onError) {
-    client.onError(options.onError);
-  }
-  if (options.onClose) {
-    client.onClose(options.onClose);
-  }
-  if (options.onOpen) {
-    client.onOpen(options.onOpen);
-  }
-  if (options.onStatus) {
-    client.onStatus(options.onStatus);
-  }
-}
-
-// Client cache for reusing connections
-const clientCache = new Map<string, ClientCacheEntry>();
-
-export function createWeiboClient(
-  account: ResolvedWeiboAccount,
-  options?: WeiboClientOptions
-): WeiboWebSocketClient {
-  const fingerprint = getWeiboConnectionFingerprint(account);
-  const cached = clientCache.get(account.accountId);
-  if (cached) {
-    if (cached.fingerprint === fingerprint) {
-      applyOptions(cached.client, options);
-      return cached.client;
-    }
-    cached.client.close();
-    clearTokenCache(account.accountId);
-    clientCache.delete(account.accountId);
-  }
-  const client = new WeiboWebSocketClient(account, options);
-  clientCache.set(account.accountId, { client, fingerprint });
-  return client;
-}
-
-export function clearClientCache(accountId?: string): void {
-  if (accountId) {
-    const cached = clientCache.get(accountId);
-    if (cached) {
-      cached.client.close();
-      clientCache.delete(accountId);
-    }
-  } else {
-    for (const cached of clientCache.values()) {
-      cached.client.close();
-    }
-    clientCache.clear();
-  }
-}

package/src/fingerprint.ts

@@ -1,25 +0,0 @@
-import type { ResolvedWeiboAccount } from "./types.js";
-
-function normalizePart(value: unknown): string {
-  return String(value ?? "").trim();
-}
-
-export function getWeiboConnectionFingerprint(account: ResolvedWeiboAccount): string {
-  return JSON.stringify({
-    appId: normalizePart(account.appId),
-    appSecret: normalizePart(account.appSecret),
-    wsEndpoint: normalizePart(account.wsEndpoint),
-    tokenEndpoint: normalizePart(account.tokenEndpoint),
-  });
-}
-
-export function getWeiboTokenFingerprint(
-  account: ResolvedWeiboAccount,
-  tokenEndpoint?: string,
-): string {
-  return JSON.stringify({
-    appId: normalizePart(account.appId),
-    appSecret: normalizePart(account.appSecret),
-    tokenEndpoint: normalizePart(tokenEndpoint ?? account.tokenEndpoint),
-  });
-}

package/src/monitor.ts

@@ -1,206 +0,0 @@
-import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
-import type { ResolvedWeiboAccount, WeiboRuntimeStatusPatch } from "./types.js";
-import { resolveWeiboAccount, listEnabledWeiboAccounts } from "./accounts.js";
-import { clearClientCache, createWeiboClient, WeiboWebSocketClient } from "./client.js";
-import { clearTokenCache, formatWeiboTokenFetchErrorMessage } from "./token.js";
-import { handleWeiboMessage, type WeiboMessageEvent } from "./bot.js";
-import { waitUntilAbortCompat } from "./plugin-sdk-compat.js";
-
-export type MonitorWeiboOpts = {
-  config?: ClawdbotConfig;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  accountId?: string;
-  statusSink?: (patch: WeiboRuntimeStatusPatch) => void;
-};
-
-// Track connections per account
-const wsClients = new Map<string, WeiboWebSocketClient>();
-
-async function monitorSingleAccount(params: {
-  cfg: ClawdbotConfig;
-  account: ResolvedWeiboAccount;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  statusSink?: (patch: WeiboRuntimeStatusPatch) => void;
-}): Promise<void> {
-  const { cfg, account, runtime, abortSignal, statusSink } = params;
-  const { accountId } = account;
-  const log = runtime?.log ?? console.log;
-  const error = runtime?.error ?? console.error;
-  const emitStatus = (patch: WeiboRuntimeStatusPatch) => statusSink?.(patch);
-
-  log(`weibo[${accountId}]: connecting WebSocket...`);
-  emitStatus({
-    running: true,
-    connected: false,
-    connectionState: "connecting",
-    lastStartAt: Date.now(),
-    lastStopAt: null,
-    lastError: null,
-  });
-
-  const client = createWeiboClient(account);
-  wsClients.set(accountId, client);
-  client.onStatus(emitStatus);
-
-  client.onMessage((data) => {
-    try {
-      const msg = data as { type?: string; payload?: unknown };
-      if (msg.type === "message" && msg.payload) {
-        emitStatus({ lastInboundAt: Date.now() });
-        const event = msg as WeiboMessageEvent;
-        handleWeiboMessage({ cfg, event, accountId, runtime }).catch((err) => {
-          error(`weibo[${accountId}]: error handling message: ${String(err)}`);
-        });
-      }
-    } catch (err) {
-      error(`weibo[${accountId}]: error processing message: ${String(err)}`);
-    }
-  });
-
-  client.onError((err) => {
-    emitStatus({
-      running: true,
-      connected: false,
-      connectionState: "error",
-      lastError: err.message,
-    });
-    error(`weibo[${accountId}]: WebSocket error: ${err.message}`);
-  });
-
-  client.onOpen(() => {
-    emitStatus({
-      running: true,
-      connected: true,
-      connectionState: "connected",
-      reconnectAttempts: 0,
-      nextRetryAt: null,
-      lastConnectedAt: Date.now(),
-      lastError: null,
-    });
-  });
-
-  client.onClose((code, reason) => {
-    emitStatus({
-      running: !abortSignal?.aborted,
-      connected: false,
-      connectionState: abortSignal?.aborted ? "stopped" : "error",
-      lastDisconnect: {
-        code,
-        reason,
-        at: Date.now(),
-      },
-    });
-    log(`weibo[${accountId}]: WebSocket closed (code: ${code}, reason: ${reason})`);
-    wsClients.delete(accountId);
-  });
-
-  // Handle abort signal
-  const handleAbort = () => {
-    log(`weibo[${accountId}]: abort signal received, closing connection`);
-    client.close();
-    wsClients.delete(accountId);
-    emitStatus({
-      running: false,
-      connected: false,
-      connectionState: "stopped",
-      nextRetryAt: null,
-      lastStopAt: Date.now(),
-    });
-  };
-
-  if (abortSignal?.aborted) {
-    handleAbort();
-    return;
-  }
-
-  abortSignal?.addEventListener("abort", handleAbort, { once: true });
-
-  try {
-    await client.connect();
-    log(`weibo[${accountId}]: WebSocket connected`);
-  } catch (err) {
-    const message = formatWeiboTokenFetchErrorMessage(err) ?? String(err);
-    emitStatus({
-      running: true,
-      connected: false,
-      connectionState: "error",
-      lastError: message,
-    });
-    error(`weibo[${accountId}]: failed to connect: ${message}`);
-  }
-
-  // Keep the channel task alive until the gateway aborts it. Returning early here
-  // causes the gateway supervisor to interpret startup as an exit and trigger
-  // provider auto-restart loops.
-  await waitUntilAbortCompat(abortSignal);
-}
-
-export async function monitorWeiboProvider(opts: MonitorWeiboOpts = {}): Promise<void> {
-  const cfg = opts.config;
-  if (!cfg) {
-    throw new Error("Config is required for Weibo monitor");
-  }
-
-  const log = opts.runtime?.log ?? console.log;
-
-  // If accountId is specified, only monitor that account
-  if (opts.accountId) {
-    const account = resolveWeiboAccount({ cfg, accountId: opts.accountId });
-    if (!account.enabled || !account.configured) {
-      throw new Error(`Weibo account "${opts.accountId}" not configured or disabled`);
-    }
-    return monitorSingleAccount({
-      cfg,
-      account,
-      runtime: opts.runtime,
-      abortSignal: opts.abortSignal,
-      statusSink: opts.statusSink,
-    });
-  }
-
-  // Otherwise, start all enabled accounts
-  const accounts = listEnabledWeiboAccounts(cfg);
-  if (accounts.length === 0) {
-    throw new Error("No enabled Weibo accounts configured");
-  }
-
-  log(`weibo: starting ${accounts.length} account(s): ${accounts.map((a) => a.accountId).join(", ")}`);
-
-  // Start all accounts in parallel
-  await Promise.all(
-    accounts.map((account) =>
-      monitorSingleAccount({
-        cfg,
-        account,
-        runtime: opts.runtime,
-        abortSignal: opts.abortSignal,
-        statusSink: opts.statusSink,
-      }),
-    ),
-  );
-}
-
-export function stopWeiboMonitor(accountId?: string): void {
-  if (accountId) {
-    const client = wsClients.get(accountId);
-    if (client) {
-      client.close();
-      wsClients.delete(accountId);
-    }
-    clearClientCache(accountId);
-    clearTokenCache(accountId);
-  } else {
-    for (const client of wsClients.values()) {
-      client.close();
-    }
-    wsClients.clear();
-    clearClientCache();
-    clearTokenCache();
-  }
-}
-
-export async function reconnectWeiboMonitor(accountId?: string): Promise<void> {
-  stopWeiboMonitor(accountId);
-}