@wecode-ai/weibo-openclaw-plugin 1.0.0

package/src/bot.ts

@@ -0,0 +1,486 @@
+import { createHash } from "node:crypto";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type {
+  WeiboInboundAttachmentPart,
+  WeiboMessageContext,
+  WeiboResponseContentPart,
+  WeiboResponseMessageInputItem,
+} from "./types.js";
+import { resolveWeiboAccount } from "./accounts.js";
+import { createWeiboOutboundStream } from "./outbound-stream.js";
+import { getWeiboRuntime } from "./runtime.js";
+import { buildAgentMediaPayloadCompat } from "./plugin-sdk-compat.js";
+
+// Simple in-memory dedup
+const processedMessages = new Set<string>();
+const MAX_INBOUND_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_INBOUND_FILE_BYTES = 5 * 1024 * 1024;
+const SUPPORTED_IMAGE_MIME_TYPES = new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+]);
+
+function isDuplicate(messageId: string): boolean {
+  if (processedMessages.has(messageId)) {
+    return true;
+  }
+  processedMessages.add(messageId);
+  // Cleanup old entries periodically
+  if (processedMessages.size > 1000) {
+    const toDelete = Array.from(processedMessages).slice(0, 500);
+    toDelete.forEach((id) => processedMessages.delete(id));
+  }
+  return false;
+}
+
+function resolveInboundMessageId(event: WeiboMessageEvent): string {
+  const explicitMessageId = event.payload.messageId.trim();
+  if (explicitMessageId) {
+    return explicitMessageId;
+  }
+
+  const digest = createHash("sha1")
+    .update(JSON.stringify({
+      fromUserId: event.payload.fromUserId,
+      text: event.payload.text ?? "",
+      timestamp: event.payload.timestamp ?? null,
+      input: event.payload.input ?? [],
+    }))
+    .digest("hex")
+    .slice(0, 16);
+
+  return `weibo_inbound_${digest}`;
+}
+
+export type WeiboMessageEvent = {
+  type: "message";
+  payload: {
+    messageId: string;
+    fromUserId: string;
+    text?: string;
+    timestamp?: number;
+    input?: WeiboResponseMessageInputItem[];
+  };
+};
+
+export type NormalizedWeiboInboundInput = {
+  text: string;
+  images: WeiboInboundAttachmentPart[];
+  files: WeiboInboundAttachmentPart[];
+};
+
+function isSupportedWeiboContentPart(part: unknown): part is WeiboResponseContentPart {
+  if (!part || typeof part !== "object") {
+    return false;
+  }
+
+  const type = (part as { type?: unknown }).type;
+  return type === "input_text" || type === "input_image" || type === "input_file";
+}
+
+export function normalizeWeiboInboundInput(event: WeiboMessageEvent): NormalizedWeiboInboundInput {
+  const textParts: string[] = [];
+  const images: WeiboInboundAttachmentPart[] = [];
+  const files: WeiboInboundAttachmentPart[] = [];
+
+  for (const item of event.payload.input ?? []) {
+    if (item.type !== "message" || item.role !== "user" || !Array.isArray(item.content)) {
+      continue;
+    }
+
+    for (const part of item.content) {
+      if (!isSupportedWeiboContentPart(part)) {
+        continue;
+      }
+
+      if (part.type === "input_text") {
+        if (typeof part.text === "string" && part.text) {
+          textParts.push(part.text);
+        }
+        continue;
+      }
+
+      const target = part.type === "input_image" ? images : files;
+      target.push({
+        mimeType: part.source.media_type,
+        filename: part.filename,
+        base64: part.source.data,
+      });
+    }
+  }
+
+  const normalizedText = textParts.length > 0
+    ? textParts.join("\n")
+    : (event.payload.text ?? "");
+
+  return {
+    text: normalizedText,
+    images,
+    files,
+  };
+}
+
+async function persistWeiboInboundAttachments(params: {
+  normalized: NormalizedWeiboInboundInput;
+  runtimeCore: ReturnType<typeof getWeiboRuntime>;
+  error: (message: string, ...args: unknown[]) => void;
+}): Promise<ReturnType<typeof buildAgentMediaPayloadCompat>> {
+  const { normalized, runtimeCore, error } = params;
+  const mediaList: Array<{ path: string; contentType?: string | null }> = [];
+
+  for (const image of normalized.images) {
+    if (!SUPPORTED_IMAGE_MIME_TYPES.has(image.mimeType)) {
+      error(`weibo: unsupported image mime type: ${image.mimeType}`);
+      continue;
+    }
+
+    try {
+      const buffer = Buffer.from(image.base64, "base64");
+      if (buffer.length === 0) {
+        error(`weibo: empty image payload: ${image.filename ?? "unknown"}`);
+        continue;
+      }
+
+      const saved = await runtimeCore.channel.media.saveMediaBuffer(
+        buffer,
+        image.mimeType,
+        "inbound",
+        MAX_INBOUND_IMAGE_BYTES,
+        image.filename,
+      );
+
+      mediaList.push({
+        path: saved.path,
+        contentType: saved.contentType,
+      });
+    } catch (err) {
+      error(`weibo: failed to persist image input: ${String(err)}`);
+    }
+  }
+
+  for (const file of normalized.files) {
+    try {
+      const buffer = Buffer.from(file.base64, "base64");
+      if (buffer.length === 0) {
+        error(`weibo: empty file payload: ${file.filename ?? "unknown"}`);
+        continue;
+      }
+
+      const saved = await runtimeCore.channel.media.saveMediaBuffer(
+        buffer,
+        file.mimeType,
+        "inbound",
+        MAX_INBOUND_FILE_BYTES,
+        file.filename,
+      );
+
+      mediaList.push({
+        path: saved.path,
+        contentType: saved.contentType,
+      });
+    } catch (err) {
+      error(`weibo: failed to persist file input: ${String(err)}`);
+    }
+  }
+
+  return buildAgentMediaPayloadCompat(mediaList);
+}
+
+export type HandleWeiboMessageParams = {
+  cfg: ClawdbotConfig;
+  event: WeiboMessageEvent;
+  accountId: string;
+  runtime?: RuntimeEnv;
+};
+
+export async function handleWeiboMessage(params: HandleWeiboMessageParams): Promise<WeiboMessageContext | null> {
+  const { cfg, event, accountId, runtime } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  const account = resolveWeiboAccount({ cfg, accountId });
+  if (!account.enabled || !account.configured) {
+    error(`weibo[${accountId}]: account not enabled or configured`);
+    return null;
+  }
+
+  const { fromUserId, timestamp } = event.payload;
+  const messageId = resolveInboundMessageId(event);
+
+  // Deduplication
+  if (isDuplicate(messageId)) {
+    return null;
+  }
+  const inboundAcceptedAt = Date.now();
+  const streamDebugEnabled = process.env.WEIBO_STREAM_DEBUG === "1";
+  const streamDebug = (tag: string, data?: Record<string, unknown>): void => {
+    if (!streamDebugEnabled) {
+      return;
+    }
+    const payload = data ? ` ${JSON.stringify(data)}` : "";
+    log(`weibo[${accountId}][stream-debug] ${tag}${payload}`);
+  };
+
+  // Get runtime core
+  const core = getWeiboRuntime();
+
+  // Build message content
+  const normalized = normalizeWeiboInboundInput(event);
+  const content = normalized.text;
+  const hasText = content.trim().length > 0;
+  const hasAttachments = normalized.images.length > 0 || normalized.files.length > 0;
+  if (!hasText && !hasAttachments) {
+    return null;
+  }
+  const mediaPayload = await persistWeiboInboundAttachments({
+    normalized,
+    runtimeCore: core,
+    error,
+  });
+  const hasPersistedMedia = Array.isArray(mediaPayload.MediaPaths) && mediaPayload.MediaPaths.length > 0;
+  if (!hasText && !hasPersistedMedia) {
+    return null;
+  }
+
+  // Resolve routing - find which agent should handle this message
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: "weibo",
+    accountId,
+    peer: {
+      kind: "direct",
+      id: fromUserId,
+    },
+  });
+
+  if (!route.agentId) {
+    log(`weibo[${accountId}]: no agent route found for ${fromUserId}`);
+    return null;
+  }
+
+  log(`weibo[${accountId}]: received message from ${fromUserId}, routing to ${route.agentId} (session=${route.sessionKey})`);
+
+  // Enqueue system event for logging/monitoring
+  const preview = content.replace(/\s+/g, " ").slice(0, 160);
+  core.system.enqueueSystemEvent(`Weibo[${accountId}] DM from ${fromUserId}: ${preview}`, {
+    sessionKey: route.sessionKey,
+    contextKey: `weibo:message:${fromUserId}:${messageId}`,
+  });
+
+  // Build the inbound envelope (message body for agent)
+  const body = core.channel.reply.formatInboundEnvelope({
+    channel: "Weibo",
+    from: fromUserId,
+    body: content,
+    timestamp: timestamp ?? Date.now(),
+    sender: { name: fromUserId, id: fromUserId },
+  });
+
+  // Resolve text chunking settings
+  const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "weibo", accountId, {
+    fallbackLimit: account.config.textChunkLimit ?? 4000,
+  });
+  const chunkMode = account.config.chunkMode
+    ?? core.channel.text.resolveChunkMode(cfg, "weibo", accountId);
+  // Weibo real-time streaming is driven by onPartialReply; disable block streaming to avoid duplicate lanes.
+  const disableBlockStreaming = true;
+  streamDebug("dispatch_init", {
+    inboundMessageId: messageId,
+    fromUserId,
+    chunkMode,
+    textChunkLimit,
+    configuredBlockStreaming: account.config.blockStreaming,
+    disableBlockStreaming,
+  });
+  let currentOutboundMessageId: string | null = null;
+  let currentOutboundChunkId = 0;
+  let hasLoggedFirstChunkLatency = false;
+
+  const ensureOutboundMessageId = async (): Promise<string> => {
+    if (currentOutboundMessageId) {
+      return currentOutboundMessageId;
+    }
+    const { generateWeiboMessageId } = await import("./send.js");
+    currentOutboundMessageId = generateWeiboMessageId();
+    currentOutboundChunkId = 0;
+    return currentOutboundMessageId;
+  };
+
+  const sendOutboundChunk = async (params: {
+    text: string;
+    done: boolean;
+    source: "partial" | "deliver" | "settled";
+  }): Promise<void> => {
+    const { sendMessageWeibo } = await import("./send.js");
+    const outboundMessageId = await ensureOutboundMessageId();
+    streamDebug("send_chunk", {
+      source: params.source,
+      messageId: outboundMessageId,
+      chunkId: currentOutboundChunkId,
+      done: params.done,
+      textLen: params.text.length,
+      preview: params.text.slice(0, 80),
+    });
+    await sendMessageWeibo({
+      cfg,
+      to: fromUserId,
+      text: params.text,
+      messageId: outboundMessageId,
+      chunkId: currentOutboundChunkId,
+      done: params.done,
+    });
+    if (!hasLoggedFirstChunkLatency && params.text.length > 0) {
+      const elapsedMs = Math.max(0, Date.now() - inboundAcceptedAt);
+      log(`weibo[${accountId}]: first chunk first-char latency=${elapsedMs}ms`);
+      hasLoggedFirstChunkLatency = true;
+    }
+    currentOutboundChunkId += 1;
+  };
+
+  const outboundStream = createWeiboOutboundStream({
+    chunkMode,
+    textChunkLimit,
+    emit: sendOutboundChunk,
+    chunkTextWithMode: (text, limit, mode) =>
+      core.channel.text.chunkTextWithMode(text, limit, mode),
+    streamDebug,
+  });
+
+  // Build final inbound context
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: content,
+    BodyForCommands: content,
+    RawBody: content,
+    CommandBody: content,
+    From: `weibo:${fromUserId}`,
+    To: fromUserId,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: "direct",
+    ConversationLabel: fromUserId,
+    SenderName: fromUserId,
+    SenderId: fromUserId,
+    Provider: "weibo" as const,
+    Surface: "weibo" as const,
+    MessageSid: messageId,
+    Timestamp: timestamp ?? Date.now(),
+    WasMentioned: true,
+    CommandAuthorized: true,
+    OriginatingChannel: "weibo" as const,
+    OriginatingTo: fromUserId,
+    ...mediaPayload,
+  });
+
+  // Create a dispatcher that sends replies back to Weibo
+  const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+    deliver: async (reply, info?: { kind?: string }) => {
+      const isFinalDeliver = info?.kind !== "block";
+      const before = outboundStream.snapshot();
+      streamDebug("deliver_enter", {
+        kind: info?.kind ?? "unknown",
+        isFinalDeliver,
+        textLen: (reply.text ?? "").length,
+        ...before,
+      });
+      await outboundStream.pushDeliverText({
+        text: reply.text ?? "",
+        isFinal: isFinalDeliver,
+      });
+      streamDebug("deliver_exit", {
+        kind: info?.kind ?? "unknown",
+        isFinalDeliver,
+        ...outboundStream.snapshot(),
+      });
+    },
+    onError: (err, info) => {
+      error(`weibo[${accountId}] ${info.kind} reply failed: ${String(err)}`);
+    },
+    onIdle: () => {
+      log(`weibo[${accountId}]: reply dispatcher idle`);
+    },
+  });
+
+  // Dispatch to agent
+  log(`weibo[${accountId}]: dispatching to agent (session=${route.sessionKey})`);
+
+  try {
+    const onSettled = async () => {
+      streamDebug("dispatcher_settled_before", {
+        currentOutboundMessageId,
+        currentOutboundChunkId,
+        ...outboundStream.snapshot(),
+      });
+      await outboundStream.settle();
+      streamDebug("dispatcher_settled_after", {
+        currentOutboundMessageId,
+        currentOutboundChunkId,
+        ...outboundStream.snapshot(),
+      });
+      currentOutboundMessageId = null;
+      currentOutboundChunkId = 0;
+      markDispatchIdle();
+    };
+
+    const runDispatch = () => core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg,
+      dispatcher,
+      replyOptions: {
+        ...replyOptions,
+        disableBlockStreaming,
+        onPartialReply: async (payload) => {
+          streamDebug("on_partial_reply", {
+            textLen: (payload.text ?? "").length,
+            preview: (payload.text ?? "").slice(0, 80),
+          });
+          await outboundStream.pushPartialSnapshot(payload.text ?? "");
+        },
+        onAssistantMessageStart: () => {
+          streamDebug("on_assistant_message_start");
+        },
+        onReasoningEnd: () => {
+          streamDebug("on_reasoning_end");
+        },
+      },
+    });
+
+    const withReplyDispatcher = (core.channel.reply as {
+      withReplyDispatcher?: (params: {
+        dispatcher: unknown;
+        run: () => Promise<{ queuedFinal: boolean; counts: { final: number } }>;
+        onSettled?: () => Promise<void> | void;
+      }) => Promise<{ queuedFinal: boolean; counts: { final: number } }>;
+    }).withReplyDispatcher;
+
+    const result = typeof withReplyDispatcher === "function"
+      ? await withReplyDispatcher({
+        dispatcher,
+        onSettled,
+        run: runDispatch,
+      })
+      : await (async () => {
+        try {
+          return await runDispatch();
+        } finally {
+          await onSettled();
+        }
+      })();
+
+    log(`weibo[${accountId}]: dispatch complete (queuedFinal=${result.queuedFinal}, replies=${result.counts.final})`);
+  } catch (err) {
+    error(`weibo[${accountId}]: failed to dispatch message: ${String(err)}`);
+  }
+
+  // Build and return message context
+  const messageContext: WeiboMessageContext = {
+    messageId,
+    senderId: fromUserId,
+    text: content,
+    createTime: timestamp,
+  };
+
+  return messageContext;
+}