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

package/src/outbound-stream.ts

@@ -1,241 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

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

package/src/runtime.ts

@@ -1,14 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

package/src/sim-page.ts

@@ -1,140 +0,0 @@
-import type { WeiboResponseContentPart, WeiboResponseMessageInputItem } from "./types.js";
-
-type SimStateLike = {
-  credentials?: Array<{
-    appId?: unknown;
-    appSecret?: unknown;
-    createdAt?: unknown;
-  }>;
-};
-
-export type LatestCredential = {
-  appId: string;
-  appSecret: string;
-};
-
-export type SimPageEndpoints = {
-  tokenUrl: string;
-  wsUrl: string;
-};
-
-export type SimInboundPayload = {
-  messageId: string;
-  fromUserId: string;
-  text: string;
-  timestamp: number;
-  input?: WeiboResponseMessageInputItem[];
-};
-
-export type SimComposerAttachment = {
-  kind: "image" | "file";
-  filename: string;
-  mimeType: string;
-  dataBase64: string;
-};
-
-export function getLatestCredentialFromState(state: SimStateLike): LatestCredential | null {
-  const credentials = Array.isArray(state.credentials) ? state.credentials : [];
-  if (credentials.length === 0) {
-    return null;
-  }
-
-  const sorted = [...credentials].sort((a, b) => {
-    const aTs = typeof a.createdAt === "number" ? a.createdAt : 0;
-    const bTs = typeof b.createdAt === "number" ? b.createdAt : 0;
-    return bTs - aTs;
-  });
-
-  const first = sorted[0];
-  const appId = String(first?.appId ?? "").trim();
-  const appSecret = String(first?.appSecret ?? "").trim();
-
-  if (!appId || !appSecret) {
-    return null;
-  }
-
-  return { appId, appSecret };
-}
-
-export function getSimPageEndpoints({
-  pageOrigin,
-  wsPort,
-}: {
-  pageOrigin: string;
-  wsPort: number;
-}): SimPageEndpoints {
-  const origin = new URL(pageOrigin);
-  const wsProtocol = origin.protocol === "https:" ? "wss:" : "ws:";
-  const tokenUrl = new URL("/open/auth/ws_token", origin).toString();
-  const wsUrl = `${wsProtocol}//${origin.hostname}:${wsPort}/ws/stream`;
-
-  return {
-    tokenUrl,
-    wsUrl,
-  };
-}
-
-export function getSimUiUrl({
-  host,
-  httpPort,
-}: {
-  host: string;
-  httpPort: number;
-}): string {
-  return `http://${host}:${httpPort}/`;
-}
-
-export function buildSimInputItems(params: {
-  text: string;
-  attachments?: SimComposerAttachment[];
-}): WeiboResponseMessageInputItem[] | undefined {
-  const content: WeiboResponseContentPart[] = [];
-  const text = params.text.trim();
-
-  if (text) {
-    content.push({
-      type: "input_text",
-      text,
-    });
-  }
-
-  for (const attachment of params.attachments ?? []) {
-    content.push({
-      type: attachment.kind === "image" ? "input_image" : "input_file",
-      filename: attachment.filename,
-      source: {
-        type: "base64",
-        media_type: attachment.mimeType,
-        data: attachment.dataBase64,
-      },
-    });
-  }
-
-  if (content.length === 0) {
-    return undefined;
-  }
-
-  return [
-    {
-      type: "message",
-      role: "user",
-      content,
-    },
-  ];
-}
-
-export function buildSimInboundPayload(params: {
-  messageId: string;
-  fromUserId: string;
-  text: string;
-  timestamp: number;
-  input?: WeiboResponseMessageInputItem[];
-}): SimInboundPayload {
-  return {
-    messageId: params.messageId,
-    fromUserId: params.fromUserId,
-    text: params.text,
-    timestamp: params.timestamp,
-    ...(params.input?.length ? { input: params.input } : {}),
-  };
-}