@wecode-ai/weibo-openclaw-plugin 1.0.0

package/src/sim-page.ts

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

package/src/sim-store.ts

@@ -0,0 +1,186 @@
+import { randomUUID } from "crypto";
+
+export type SimLogLevel = "info" | "warn" | "error";
+
+export type SimCredential = {
+  appId: string;
+  appSecret: string;
+  createdAt: number;
+};
+
+export type SimTokenInfo = {
+  token: string;
+  appId: string;
+  createdAt: number;
+  expireIn: number;
+};
+
+export type SimMessageDirection = "inbound" | "outbound";
+
+export type SimMessageRecord = {
+  id: string;
+  direction: SimMessageDirection;
+  appId: string;
+  fromUserId?: string;
+  toUserId?: string;
+  text: string;
+  timestamp: number;
+  wsType?: string;
+  rawText?: string;
+  rawPayload?: unknown;
+};
+
+export type SimLogRecord = {
+  id: string;
+  level: SimLogLevel;
+  message: string;
+  timestamp: number;
+  details?: unknown;
+};
+
+type SimStoreOptions = {
+  maxLogEntries?: number;
+  maxMessageEntries?: number;
+};
+
+type AppendMessageInput = Omit<SimMessageRecord, "id"> & { id?: string };
+
+const DEFAULT_MAX_LOG_ENTRIES = 300;
+const DEFAULT_MAX_MESSAGE_ENTRIES = 500;
+
+function randomSuffix(): string {
+  return randomUUID().replace(/-/g, "").slice(0, 16);
+}
+
+function boundedPush<T>(arr: T[], value: T, max: number): void {
+  arr.push(value);
+  if (arr.length > max) {
+    arr.splice(0, arr.length - max);
+  }
+}
+
+export function createSimStore(options: SimStoreOptions = {}) {
+  const maxLogEntries = options.maxLogEntries ?? DEFAULT_MAX_LOG_ENTRIES;
+  const maxMessageEntries = options.maxMessageEntries ?? DEFAULT_MAX_MESSAGE_ENTRIES;
+
+  const credentialsByAppId = new Map<string, SimCredential>();
+  const tokenByValue = new Map<string, SimTokenInfo>();
+  const latestTokenByAppId = new Map<string, string>();
+  const messages: SimMessageRecord[] = [];
+  const logs: SimLogRecord[] = [];
+
+  function issueCredentials(): SimCredential {
+    const createdAt = Date.now();
+    const credential = registerCredentials(
+      `app_${createdAt}_${randomSuffix()}`,
+      `secret_${randomSuffix()}`,
+      createdAt,
+    );
+    return credential;
+  }
+
+  function registerCredentials(appId: string, appSecret: string, createdAt = Date.now()): SimCredential {
+    const credential: SimCredential = {
+      appId: String(appId),
+      appSecret: String(appSecret),
+      createdAt,
+    };
+    credentialsByAppId.set(credential.appId, credential);
+    return credential;
+  }
+
+  function listCredentials(): SimCredential[] {
+    return Array.from(credentialsByAppId.values()).sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  function issueToken(appId: string, appSecret: string, ttlSeconds: number): SimTokenInfo {
+    const credential = credentialsByAppId.get(appId);
+    if (!credential || credential.appSecret !== appSecret) {
+      throw new Error("Invalid credentials");
+    }
+
+    const prior = latestTokenByAppId.get(appId);
+    if (prior) {
+      tokenByValue.delete(prior);
+    }
+
+    const tokenInfo: SimTokenInfo = {
+      token: `wb_${randomSuffix()}_${Date.now()}`,
+      appId,
+      createdAt: Date.now(),
+      expireIn: ttlSeconds,
+    };
+
+    tokenByValue.set(tokenInfo.token, tokenInfo);
+    latestTokenByAppId.set(appId, tokenInfo.token);
+    return tokenInfo;
+  }
+
+  function validateToken(token: string): SimTokenInfo | null {
+    const tokenInfo = tokenByValue.get(token);
+    if (!tokenInfo) {
+      return null;
+    }
+
+    const expiresAt = tokenInfo.createdAt + tokenInfo.expireIn * 1000;
+    if (Date.now() > expiresAt) {
+      tokenByValue.delete(token);
+      if (latestTokenByAppId.get(tokenInfo.appId) === token) {
+        latestTokenByAppId.delete(tokenInfo.appId);
+      }
+      return null;
+    }
+
+    return tokenInfo;
+  }
+
+  function listTokens(): SimTokenInfo[] {
+    return Array.from(tokenByValue.values()).sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  function appendMessage(message: AppendMessageInput): SimMessageRecord {
+    const record: SimMessageRecord = {
+      ...message,
+      id: message.id ?? `msg_${Date.now()}_${randomSuffix()}`,
+    };
+    boundedPush(messages, record, maxMessageEntries);
+    return record;
+  }
+
+  function listMessages(limit = 50): SimMessageRecord[] {
+    if (limit <= 0) return [];
+    return messages.slice(-limit).reverse();
+  }
+
+  function appendLog(level: SimLogLevel, message: string, details?: unknown): SimLogRecord {
+    const record: SimLogRecord = {
+      id: `log_${Date.now()}_${randomSuffix()}`,
+      level,
+      message,
+      details,
+      timestamp: Date.now(),
+    };
+    boundedPush(logs, record, maxLogEntries);
+    return record;
+  }
+
+  function listLogs(limit = 200): SimLogRecord[] {
+    if (limit <= 0) return [];
+    return logs.slice(-limit).reverse();
+  }
+
+  return {
+    registerCredentials,
+    issueCredentials,
+    listCredentials,
+    issueToken,
+    validateToken,
+    listTokens,
+    appendMessage,
+    listMessages,
+    appendLog,
+    listLogs,
+  };
+}
+
+export type SimStore = ReturnType<typeof createSimStore>;

package/src/targets.ts

@@ -0,0 +1,14 @@
+export function normalizeWeiboTarget(target: string): string {
+  const trimmed = target.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("user:")) return trimmed;
+  return `user:${trimmed}`;
+}
+
+export function looksLikeWeiboId(str: string): boolean {
+  return /^\d+$/.test(str.trim());
+}
+
+export function formatWeiboTarget(userId: string): string {
+  return `user:${userId}`;
+}

package/src/token.ts

@@ -0,0 +1,207 @@
+import type { ResolvedWeiboAccount } from "./types.js";
+import { getWeiboTokenFingerprint } from "./fingerprint.js";
+
+export type WeiboTokenResponse = {
+  data: {
+    token: string;
+    expire_in: number;
+  };
+};
+
+export type WeiboTokenResult = {
+  token: string;
+  expiresIn: number;
+  acquiredAt: number;
+};
+
+type CachedWeiboTokenResult = WeiboTokenResult & {
+  fingerprint: string;
+};
+
+const TOKEN_FETCH_BASE_DELAY_MS = 1_000;
+const TOKEN_FETCH_MAX_DELAY_MS = 8_000;
+const TOKEN_FETCH_MAX_RETRIES = 2;
+const RETRYABLE_TOKEN_STATUS_CODES = new Set([408, 425, 429, 500, 502, 503, 504]);
+
+// Token cache per account
+const tokenCache = new Map<string, CachedWeiboTokenResult>();
+
+// Default token endpoint - configure in your openclaw.config.json
+// Example: tokenEndpoint: "http://localhost:9810/open/auth/ws_token"
+const DEFAULT_TOKEN_ENDPOINT = "http://open-im.api.weibo.com/open/auth/ws_token";
+
+export class WeiboTokenFetchError extends Error {
+  retryable: boolean;
+  status?: number;
+
+  constructor(message: string, options: { retryable: boolean; status?: number }) {
+    super(message);
+    this.name = "WeiboTokenFetchError";
+    this.retryable = options.retryable;
+    this.status = options.status;
+  }
+}
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readTokenEndpoint(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function isRetryableStatus(status: number): boolean {
+  return RETRYABLE_TOKEN_STATUS_CODES.has(status);
+}
+
+function toTokenFetchError(err: unknown): WeiboTokenFetchError {
+  if (err instanceof WeiboTokenFetchError) {
+    return err;
+  }
+  if (err instanceof Error) {
+    return new WeiboTokenFetchError(err.message, { retryable: true });
+  }
+  return new WeiboTokenFetchError(String(err), { retryable: true });
+}
+
+export function formatWeiboTokenFetchErrorMessage(err: unknown): string | null {
+  if (!(err instanceof WeiboTokenFetchError)) {
+    return null;
+  }
+  return `获取 token 失败: ${err.message}`;
+}
+
+export function isRetryableWeiboTokenFetchError(err: unknown): boolean | null {
+  if (!(err instanceof WeiboTokenFetchError)) {
+    return null;
+  }
+  return err.retryable;
+}
+
+export async function fetchWeiboToken(
+  account: ResolvedWeiboAccount,
+  tokenEndpoint?: string
+): Promise<WeiboTokenResult> {
+  const { appId, appSecret } = account;
+
+  if (!appId || !appSecret) {
+    throw new Error(`Credentials not configured for account "${account.accountId}"`);
+  }
+
+  // Defensive runtime coercion: config may come from untyped sources.
+  const normalizedAppId = String(appId);
+  const normalizedAppSecret = String(appSecret);
+
+  const endpoint = readTokenEndpoint(tokenEndpoint) ?? DEFAULT_TOKEN_ENDPOINT;
+  const fingerprint = getWeiboTokenFingerprint(account, endpoint);
+
+  for (let attempt = 0; ; attempt++) {
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          app_id: normalizedAppId,
+          app_secret: normalizedAppSecret,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new WeiboTokenFetchError(
+          `Failed to fetch token: ${response.status} ${response.statusText}`,
+          {
+            retryable: isRetryableStatus(response.status),
+            status: response.status,
+          }
+        );
+      }
+
+      const result = (await response.json()) as WeiboTokenResponse;
+
+      if (!result.data?.token) {
+        throw new WeiboTokenFetchError("Invalid token response: missing token", {
+          retryable: false,
+        });
+      }
+
+      const tokenResult: CachedWeiboTokenResult = {
+        token: result.data.token,
+        expiresIn: result.data.expire_in,
+        acquiredAt: Date.now(),
+        fingerprint,
+      };
+
+      // Cache the token
+      tokenCache.set(account.accountId, tokenResult);
+
+      return tokenResult;
+    } catch (err) {
+      const tokenError = toTokenFetchError(err);
+      if (!tokenError.retryable || attempt >= TOKEN_FETCH_MAX_RETRIES) {
+        throw tokenError;
+      }
+
+      const delay = Math.min(
+        TOKEN_FETCH_BASE_DELAY_MS * Math.pow(2, attempt),
+        TOKEN_FETCH_MAX_DELAY_MS
+      );
+      await sleep(delay);
+    }
+  }
+}
+
+export function getCachedToken(
+  accountId: string,
+  fingerprint?: string
+): WeiboTokenResult | undefined {
+  const cached = tokenCache.get(accountId);
+  if (!cached) return undefined;
+
+  if (fingerprint && cached.fingerprint !== fingerprint) {
+    tokenCache.delete(accountId);
+    return undefined;
+  }
+
+  // Check if token is expired (with 60s buffer)
+  const expiresAt = cached.acquiredAt + cached.expiresIn * 1000 - 60000;
+  if (Date.now() > expiresAt) {
+    tokenCache.delete(accountId);
+    return undefined;
+  }
+
+  return cached;
+}
+
+export function clearTokenCache(accountId?: string): void {
+  if (accountId) {
+    tokenCache.delete(accountId);
+  } else {
+    tokenCache.clear();
+  }
+}
+
+export async function getValidToken(
+  account: ResolvedWeiboAccount,
+  tokenEndpoint?: string
+): Promise<string> {
+  const fingerprint = getWeiboTokenFingerprint(
+    account,
+    readTokenEndpoint(tokenEndpoint) ?? readTokenEndpoint(account.tokenEndpoint) ?? DEFAULT_TOKEN_ENDPOINT
+  );
+
+  // Try to get cached token
+  const cached = getCachedToken(account.accountId, fingerprint);
+  if (cached) {
+    return cached.token;
+  }
+
+  // Fetch new token
+  const result = await fetchWeiboToken(account, readTokenEndpoint(tokenEndpoint));
+  return result.token;
+}

package/src/tools-config.ts

@@ -0,0 +1,55 @@
+import type { WeiboToolsConfig } from "./types.js";
+
+export type ResolvedWeiboToolsConfig = Required<{
+  search: boolean;
+  myWeibo: boolean;
+  hotSearch: boolean;
+}>;
+
+const DEFAULT_TOOLS_CONFIG: ResolvedWeiboToolsConfig = {
+  search: true, // Search enabled by default
+  myWeibo: true, // My weibo enabled by default
+  hotSearch: true, // Hot search enabled by default
+};
+
+/**
+ * Resolve tools configuration with defaults.
+ * Missing values default to true (enabled).
+ */
+export function resolveToolsConfig(
+  tools: WeiboToolsConfig | undefined
+): ResolvedWeiboToolsConfig {
+  if (!tools) {
+    return { ...DEFAULT_TOOLS_CONFIG };
+  }
+  return {
+    search: tools.search ?? DEFAULT_TOOLS_CONFIG.search,
+    myWeibo: tools.myWeibo ?? DEFAULT_TOOLS_CONFIG.myWeibo,
+    hotSearch: tools.hotSearch ?? DEFAULT_TOOLS_CONFIG.hotSearch,
+  };
+}
+
+/**
+ * Check if any account has a specific tool enabled.
+ * Used to determine whether to register a tool at all.
+ */
+export function resolveAnyEnabledWeiboToolsConfig(
+  accounts: Array<{ config: { tools?: WeiboToolsConfig } }>
+): ResolvedWeiboToolsConfig {
+  const merged: ResolvedWeiboToolsConfig = {
+    search: false,
+    myWeibo: false,
+    hotSearch: false,
+  };
+  for (const account of accounts) {
+    const cfg = resolveToolsConfig(account.config.tools);
+    merged.search = merged.search || cfg.search;
+    merged.myWeibo = merged.myWeibo || cfg.myWeibo;
+    merged.hotSearch = merged.hotSearch || cfg.hotSearch;
+  }
+  // If no accounts have explicit config, use defaults
+  if (accounts.length === 0) {
+    return { ...DEFAULT_TOOLS_CONFIG };
+  }
+  return merged;
+}

package/src/types.ts

@@ -0,0 +1,95 @@
+import type { z } from "zod";
+import type { WeiboConfigSchema, WeiboAccountConfigSchema, WeiboToolsConfigSchema } from "./config-schema.js";
+
+export type WeiboConfig = z.infer<typeof WeiboConfigSchema>;
+export type WeiboAccountConfig = z.infer<typeof WeiboAccountConfigSchema>;
+export type WeiboToolsConfig = z.infer<typeof WeiboToolsConfigSchema>;
+
+export type ResolvedWeiboAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  name?: string;
+  appId?: string;
+  appSecret?: string;
+  wsEndpoint?: string;
+  tokenEndpoint?: string;
+  config: WeiboAccountConfig;
+};
+
+export type WeiboConnectionState =
+  | "idle"
+  | "connecting"
+  | "connected"
+  | "backoff"
+  | "error"
+  | "stopped";
+
+export type WeiboDisconnectInfo = {
+  code: number;
+  reason: string;
+  at: number;
+};
+
+export type WeiboRuntimeStatusPatch = {
+  running?: boolean;
+  connected?: boolean;
+  connectionState?: WeiboConnectionState;
+  reconnectAttempts?: number;
+  nextRetryAt?: number | null;
+  lastConnectedAt?: number | null;
+  lastDisconnect?: WeiboDisconnectInfo | null;
+  lastError?: string | null;
+  lastStartAt?: number | null;
+  lastStopAt?: number | null;
+  lastInboundAt?: number | null;
+  lastOutboundAt?: number | null;
+};
+
+export type WeiboMessageContext = {
+  messageId: string;
+  senderId: string;
+  text: string;
+  createTime?: number;
+};
+
+export type WeiboResponseInputSource = {
+  type: "base64";
+  media_type: string;
+  data: string;
+};
+
+export type WeiboResponseContentPart =
+  | {
+    type: "input_text";
+    text: string;
+  }
+  | {
+    type: "input_image";
+    source: WeiboResponseInputSource;
+    filename?: string;
+  }
+  | {
+    type: "input_file";
+    source: WeiboResponseInputSource;
+    filename?: string;
+  };
+
+export type WeiboResponseMessageInputItem = {
+  type: "message";
+  role: "system" | "developer" | "user" | "assistant";
+  content: WeiboResponseContentPart[];
+};
+
+export type WeiboInboundAttachmentPart = {
+  mimeType: string;
+  filename?: string;
+  base64: string;
+};
+
+export type WeiboSendResult = {
+  messageId: string;
+  chatId: string;
+  chunkId: number;
+  done: boolean;
+};