@wecode-ai/weibo-openclaw-plugin 1.0.0

package/src/monitor.ts

@@ -0,0 +1,206 @@
+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);
+}

package/src/outbound-stream.ts

@@ -0,0 +1,241 @@
+export type WeiboChunkMode = "length" | "newline" | "raw";
+
+type StreamDebugFn = (tag: string, data?: Record<string, unknown>) => void;
+
+export type WeiboOutboundEmitFn = (params: {
+  text: string;
+  done: boolean;
+  source: "partial" | "deliver" | "settled";
+}) => Promise<void>;
+
+type CreateWeiboOutboundStreamParams = {
+  chunkMode: WeiboChunkMode;
+  textChunkLimit: number;
+  emit: WeiboOutboundEmitFn;
+  chunkTextWithMode: (text: string, limit: number, mode: "length" | "newline") => Iterable<string>;
+  streamDebug?: StreamDebugFn;
+};
+
+type StreamStateSnapshot = {
+  hasSeenPartial: boolean;
+  hasEmittedChunks: boolean;
+  hasEmittedDone: boolean;
+  newlineBufferLen: number;
+  pendingDeliverBufferLen: number;
+};
+
+const PARAGRAPH_DELIMITER_RE = /\n[\t ]*\n+/g;
+
+function findLastParagraphDelimiterEnd(value: string): number {
+  let lastEnd = -1;
+  let match: RegExpExecArray | null = null;
+  while ((match = PARAGRAPH_DELIMITER_RE.exec(value)) !== null) {
+    lastEnd = match.index + match[0].length;
+  }
+  return lastEnd;
+}
+
+function resolveDeltaFromSnapshot(previous: string, next: string): {
+  delta: string;
+  nextSnapshot: string;
+  nonMonotonic: boolean;
+} {
+  if (!next || next === previous) {
+    return { delta: "", nextSnapshot: next, nonMonotonic: false };
+  }
+  if (next.startsWith(previous)) {
+    return {
+      delta: next.slice(previous.length),
+      nextSnapshot: next,
+      nonMonotonic: false,
+    };
+  }
+  if (previous.startsWith(next)) {
+    return {
+      delta: "",
+      nextSnapshot: next,
+      nonMonotonic: true,
+    };
+  }
+
+  let prefixLen = 0;
+  const maxLen = Math.min(previous.length, next.length);
+  while (prefixLen < maxLen && previous.charCodeAt(prefixLen) === next.charCodeAt(prefixLen)) {
+    prefixLen += 1;
+  }
+  return {
+    delta: next.slice(prefixLen),
+    nextSnapshot: next,
+    nonMonotonic: true,
+  };
+}
+
+export function createWeiboOutboundStream(params: CreateWeiboOutboundStreamParams) {
+  const {
+    chunkMode,
+    textChunkLimit,
+    emit,
+    chunkTextWithMode,
+    streamDebug,
+  } = params;
+
+  let hasSeenPartial = false;
+  let hasEmittedChunks = false;
+  let hasEmittedDone = false;
+  let lastPartialSnapshot = "";
+  let newlineBuffer = "";
+  let pendingDeliverBuffer = "";
+
+  const splitOutboundText = (text: string): string[] =>
+    chunkMode === "raw"
+      ? [text]
+      : Array.from(chunkTextWithMode(text, textChunkLimit, chunkMode));
+
+  const emitChunks = async (chunks: string[], markLastDone: boolean, source: "partial" | "deliver" | "settled"): Promise<boolean> => {
+    const normalizedChunks = chunks.filter((chunk) => chunk.length > 0);
+    streamDebug?.("emit_chunks_prepare", {
+      candidateCount: chunks.length,
+      normalizedCount: normalizedChunks.length,
+      markLastDone,
+      chunkMode,
+      source,
+    });
+    if (normalizedChunks.length === 0) {
+      return false;
+    }
+
+    for (let index = 0; index < normalizedChunks.length; index += 1) {
+      const done = markLastDone && index === normalizedChunks.length - 1;
+      await emit({
+        text: normalizedChunks[index] ?? "",
+        done,
+        source,
+      });
+      hasEmittedChunks = true;
+      if (done) {
+        hasEmittedDone = true;
+      }
+    }
+    return true;
+  };
+
+  const flushText = async (text: string, isFinal: boolean, source: "partial" | "deliver" | "settled"): Promise<boolean> => {
+    if (chunkMode === "newline") {
+      if (!isFinal) {
+        newlineBuffer += text;
+        const flushBoundary = findLastParagraphDelimiterEnd(newlineBuffer);
+        streamDebug?.("newline_buffered", {
+          source,
+          incomingLen: text.length,
+          bufferLen: newlineBuffer.length,
+          flushBoundary,
+        });
+        if (flushBoundary <= 0) {
+          return false;
+        }
+        const flushableText = newlineBuffer.slice(0, flushBoundary);
+        newlineBuffer = newlineBuffer.slice(flushBoundary);
+        streamDebug?.("newline_flush", {
+          source,
+          flushableLen: flushableText.length,
+          remainingBufferLen: newlineBuffer.length,
+        });
+        return emitChunks(splitOutboundText(flushableText), false, source);
+      }
+
+      const textToSend = `${newlineBuffer}${text}`;
+      newlineBuffer = "";
+      return emitChunks(splitOutboundText(textToSend), true, source);
+    }
+
+    return emitChunks(splitOutboundText(text), isFinal, source);
+  };
+
+  const finalizeWithDoneMarker = async (source: "deliver" | "settled"): Promise<void> => {
+    if (hasEmittedDone) {
+      return;
+    }
+    const emitted = await flushText("", true, source);
+    if (!emitted && hasEmittedChunks && !hasEmittedDone) {
+      streamDebug?.("emit_done_marker", { source, reason: "final_without_text" });
+      await emit({
+        text: "",
+        done: true,
+        source,
+      });
+      hasEmittedDone = true;
+    }
+  };
+
+  return {
+    async pushPartialSnapshot(snapshot: string): Promise<void> {
+      if (!snapshot) {
+        return;
+      }
+
+      hasSeenPartial = true;
+      const previousSnapshotLen = lastPartialSnapshot.length;
+      const deltaResult = resolveDeltaFromSnapshot(lastPartialSnapshot, snapshot);
+      lastPartialSnapshot = deltaResult.nextSnapshot;
+
+      streamDebug?.("partial_snapshot", {
+        snapshotLen: snapshot.length,
+        prevLen: previousSnapshotLen,
+        deltaLen: deltaResult.delta.length,
+        nonMonotonic: deltaResult.nonMonotonic,
+      });
+
+      if (!deltaResult.delta) {
+        return;
+      }
+      await flushText(deltaResult.delta, false, "partial");
+    },
+
+    async pushDeliverText(params: { text: string; isFinal: boolean }): Promise<void> {
+      const text = params.text ?? "";
+      if (!params.isFinal) {
+        if (!hasSeenPartial && text.length > 0) {
+          pendingDeliverBuffer += text;
+          streamDebug?.("deliver_buffered", {
+            kind: "block",
+            incomingLen: text.length,
+            pendingDeliverBufferLen: pendingDeliverBuffer.length,
+          });
+        }
+        return;
+      }
+
+      if (hasSeenPartial) {
+        if (text.length > 0) {
+          await this.pushPartialSnapshot(text);
+        }
+        await finalizeWithDoneMarker("deliver");
+        return;
+      }
+
+      const fallbackText = `${pendingDeliverBuffer}${text}`;
+      pendingDeliverBuffer = "";
+      await flushText(fallbackText, true, "deliver");
+      await finalizeWithDoneMarker("deliver");
+    },
+
+    async settle(): Promise<void> {
+      if (!hasSeenPartial && pendingDeliverBuffer.length > 0) {
+        const buffered = pendingDeliverBuffer;
+        pendingDeliverBuffer = "";
+        await flushText(buffered, true, "settled");
+      }
+      await finalizeWithDoneMarker("settled");
+    },
+
+    snapshot(): StreamStateSnapshot {
+      return {
+        hasSeenPartial,
+        hasEmittedChunks,
+        hasEmittedDone,
+        newlineBufferLen: newlineBuffer.length,
+        pendingDeliverBufferLen: pendingDeliverBuffer.length,
+      };
+    },
+  };
+}

package/src/outbound.ts

@@ -0,0 +1,49 @@
+import type {
+  ChannelOutboundAdapter,
+  ChannelOutboundContext,
+} from "openclaw/plugin-sdk";
+import { sendMessageWeibo } from "./send.js";
+
+// Simple text chunker - splits by character length
+// Mode is handled by the SDK's chunkTextWithMode helper
+function chunkText(text: string, limit: number): string[] {
+  if (text.length <= limit) {
+    return [text];
+  }
+
+  const chunks: string[] = [];
+  for (let i = 0; i < text.length; i += limit) {
+    chunks.push(text.slice(i, i + limit));
+  }
+
+  return chunks;
+}
+
+export const weiboOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: chunkText,
+  chunkerMode: "text",
+  textChunkLimit: 2000, // Weibo DM text limit is around 2000 chars
+
+  sendText: async (ctx: ChannelOutboundContext) => {
+    const { cfg, to, text, accountId } = ctx;
+
+    const result = await sendMessageWeibo({
+      cfg,
+      to: to ?? "",
+      text: text ?? "",
+      accountId: accountId ?? undefined,
+    });
+
+    return {
+      channel: "weibo" as const,
+      messageId: result.messageId,
+      chatId: result.chatId,
+    };
+  },
+
+  sendMedia: async (_ctx: ChannelOutboundContext) => {
+    // Weibo plugin doesn't support media
+    throw new Error("Weibo channel does not support media messages");
+  },
+};

package/src/plugin-sdk-compat.ts

@@ -0,0 +1,82 @@
+import * as pluginSdk from "openclaw/plugin-sdk";
+
+export type MediaItem = {
+  path: string;
+  contentType?: string | null;
+};
+
+export type AgentMediaPayload = {
+  MediaPath?: string;
+  MediaPaths?: string[];
+  MediaType?: string;
+  MediaTypes?: string[];
+  MediaUrl?: string;
+  MediaUrls?: string[];
+};
+
+type PluginSdkCompat = {
+  buildAgentMediaPayload?: (mediaList: MediaItem[]) => AgentMediaPayload;
+  buildMediaPayload?: (mediaList: MediaItem[]) => AgentMediaPayload;
+  waitUntilAbort?: (abortSignal?: AbortSignal) => Promise<void>;
+};
+
+function buildAgentMediaPayloadFallback(mediaList: MediaItem[]): AgentMediaPayload {
+  const normalized = mediaList.filter((item) => typeof item.path === "string" && item.path.trim().length > 0);
+  if (normalized.length === 0) {
+    return {};
+  }
+
+  const paths = normalized.map((item) => item.path);
+  const types = normalized.map((item) => item.contentType ?? undefined).filter((value): value is string => typeof value === "string");
+  const payload: AgentMediaPayload = {
+    MediaPath: paths[0],
+    MediaPaths: paths,
+    MediaUrl: paths[0],
+    MediaUrls: paths,
+  };
+
+  if (types.length > 0) {
+    payload.MediaType = types[0];
+    payload.MediaTypes = types;
+  }
+
+  return payload;
+}
+
+function waitUntilAbortFallback(abortSignal?: AbortSignal): Promise<void> {
+  if (!abortSignal) {
+    return new Promise<void>(() => undefined);
+  }
+  if (abortSignal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise<void>((resolve) => {
+    abortSignal.addEventListener("abort", () => resolve(), { once: true });
+  });
+}
+
+export function buildAgentMediaPayloadCompat(
+  mediaList: MediaItem[],
+  sdk: PluginSdkCompat = pluginSdk as PluginSdkCompat,
+): AgentMediaPayload {
+  if (typeof sdk.buildAgentMediaPayload === "function") {
+    return sdk.buildAgentMediaPayload(mediaList);
+  }
+
+  if (typeof sdk.buildMediaPayload === "function") {
+    return sdk.buildMediaPayload(mediaList);
+  }
+
+  return buildAgentMediaPayloadFallback(mediaList);
+}
+
+export function waitUntilAbortCompat(
+  abortSignal?: AbortSignal,
+  sdk: PluginSdkCompat = pluginSdk as PluginSdkCompat,
+): Promise<void> {
+  if (typeof sdk.waitUntilAbort === "function") {
+    return sdk.waitUntilAbort(abortSignal);
+  }
+
+  return waitUntilAbortFallback(abortSignal);
+}

package/src/policy.ts

@@ -0,0 +1,10 @@
+export function resolveWeiboAllowlistMatch({
+  userId,
+  allowFrom,
+}: {
+  userId: string;
+  allowFrom: string[];
+}): boolean {
+  if (allowFrom.includes("*")) return true;
+  return allowFrom.includes(userId);
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let weiboRuntime: PluginRuntime | undefined;
+
+export function setWeiboRuntime(runtime: PluginRuntime): void {
+  weiboRuntime = runtime;
+}
+
+export function getWeiboRuntime(): PluginRuntime {
+  if (!weiboRuntime) {
+    throw new Error("Weibo runtime not initialized");
+  }
+  return weiboRuntime;
+}

package/src/search-schema.ts

@@ -0,0 +1,7 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const WeiboSearchSchema = Type.Object({
+  query: Type.String({ description: "搜索关键词" }),
+});
+
+export type WeiboSearchParams = Static<typeof WeiboSearchSchema>;

package/src/send.ts

@@ -0,0 +1,80 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { WeiboSendResult } from "./types.js";
+import { resolveWeiboAccount } from "./accounts.js";
+import { createWeiboClient } from "./client.js";
+import { normalizeWeiboTarget } from "./targets.js";
+
+export type SendWeiboMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  accountId?: string;
+  messageId?: string;
+  chunkId?: number;
+  done?: boolean;
+};
+
+export function generateWeiboMessageId(): string {
+  return `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+
+function normalizeChunkId(chunkId?: number): number {
+  if (typeof chunkId !== "number" || !Number.isFinite(chunkId) || chunkId < 0) {
+    return 0;
+  }
+  return Math.floor(chunkId);
+}
+
+export async function sendMessageWeibo(params: SendWeiboMessageParams): Promise<WeiboSendResult> {
+  const { cfg, to, text, accountId, messageId, chunkId, done } = params;
+  const streamDebugEnabled = process.env.WEIBO_STREAM_DEBUG === "1";
+  const account = resolveWeiboAccount({ cfg, accountId });
+
+  if (!account.configured) {
+    throw new Error(`Weibo account "${account.accountId}" not configured`);
+  }
+
+  const client = createWeiboClient(account);
+  const receiveId = normalizeWeiboTarget(to);
+
+  if (!receiveId) {
+    throw new Error(`Invalid Weibo target: ${to}`);
+  }
+
+  const userId = receiveId.replace(/^user:/, "");
+  const outboundMessageId = typeof messageId === "string" && messageId.trim()
+    ? messageId.trim()
+    : generateWeiboMessageId();
+  const outboundChunkId = normalizeChunkId(chunkId);
+  const outboundDone = typeof done === "boolean" ? done : true;
+
+  client.send({
+    type: "send_message",
+    payload: {
+      toUserId: userId,
+      text: text ?? "",
+      messageId: outboundMessageId,
+      chunkId: outboundChunkId,
+      done: outboundDone,
+    },
+  });
+  if (streamDebugEnabled) {
+    console.log(
+      `[weibo][stream-debug] ws_send ${JSON.stringify({
+        toUserId: userId,
+        messageId: outboundMessageId,
+        chunkId: outboundChunkId,
+        done: outboundDone,
+        textLen: (text ?? "").length,
+        preview: (text ?? "").slice(0, 80),
+      })}`,
+    );
+  }
+
+  return {
+    messageId: outboundMessageId,
+    chatId: receiveId,
+    chunkId: outboundChunkId,
+    done: outboundDone,
+  };
+}