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

package/src/sim-store.ts

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

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

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

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

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