@tencent-connect/openclaw-qqbot 1.7.1 → 2.0.0

package/src/reply-dispatcher.ts

@@ -1,334 +0,0 @@
-import path from "node:path";
-import type { ResolvedQQBotAccount } from "./types.js";
-import { getAccessToken, sendC2CMessage, sendChannelMessage, sendGroupMessage, clearTokenCache, sendC2CImageMessage, sendGroupImageMessage, sendC2CVoiceMessage, sendGroupVoiceMessage, sendC2CVideoMessage, sendGroupVideoMessage, sendC2CFileMessage, sendGroupFileMessage } from "./api.js";
-import { parseQQBotPayload, encodePayloadForCron, isCronReminderPayload, isMediaPayload, type MediaPayload } from "./utils/payload.js";
-import { resolveTTSConfig, textToSilk, formatDuration } from "./utils/audio-convert.js";
-import { checkFileSize, readFileAsync, fileExistsAsync, formatFileSize, getMaxUploadSize } from "./utils/file-utils.js";
-import { getQQBotDataDir, normalizePath, sanitizeFileName } from "./utils/platform.js";
-
-export interface MessageTarget {
-  type: "c2c" | "guild" | "dm" | "group";
-  senderId: string;
-  messageId: string;
-  channelId?: string;
-  groupOpenid?: string;
-}
-
-export interface ReplyContext {
-  target: MessageTarget;
-  account: ResolvedQQBotAccount;
-  cfg: unknown;
-  log?: {
-    info: (msg: string) => void;
-    error: (msg: string) => void;
-    debug?: (msg: string) => void;
-  };
-}
-
-/**
- * 带 token 过期重试的消息发送
- */
-export async function sendWithTokenRetry<T>(
-  appId: string,
-  clientSecret: string,
-  sendFn: (token: string) => Promise<T>,
-  log?: ReplyContext["log"],
-  accountId?: string,
-): Promise<T> {
-  try {
-    const token = await getAccessToken(appId, clientSecret);
-    return await sendFn(token);
-  } catch (err) {
-    const errMsg = String(err);
-    if (errMsg.includes("401") || errMsg.includes("token") || errMsg.includes("access_token")) {
-      log?.info(`[qqbot:${accountId}] Token may be expired, refreshing...`);
-      clearTokenCache(appId);
-      const newToken = await getAccessToken(appId, clientSecret);
-      return await sendFn(newToken);
-    } else {
-      throw err;
-    }
-  }
-}
-
-/**
- * 根据消息类型路由发送文本
- */
-export async function sendTextToTarget(
-  ctx: ReplyContext,
-  text: string,
-  refIdx?: string,
-): Promise<void> {
-  const { target, account } = ctx;
-  await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-    if (target.type === "c2c") {
-      await sendC2CMessage(token, target.senderId, text, target.messageId, refIdx);
-    } else if (target.type === "group" && target.groupOpenid) {
-      await sendGroupMessage(token, target.groupOpenid, text, target.messageId);
-    } else if (target.channelId) {
-      await sendChannelMessage(token, target.channelId, text, target.messageId);
-    } else if (target.type === "dm") {
-      await sendC2CMessage(token, target.senderId, text, target.messageId, refIdx);
-    }
-  }, ctx.log, account.accountId);
-}
-
-/**
- * 发送错误提示给用户
- */
-export async function sendErrorToTarget(ctx: ReplyContext, errorText: string): Promise<void> {
-  try {
-    await sendTextToTarget(ctx, errorText);
-  } catch (sendErr) {
-    ctx.log?.error(`[qqbot:${ctx.account.accountId}] Failed to send error message: ${sendErr}`);
-  }
-}
-
-/**
- * 处理结构化载荷（QQBOT_PAYLOAD: 前缀的 JSON）
- * 返回 true 表示已处理，false 表示不是结构化载荷
- */
-export async function handleStructuredPayload(
-  ctx: ReplyContext,
-  replyText: string,
-  recordActivity: () => void,
-): Promise<boolean> {
-  const { target, account, cfg, log } = ctx;
-  const payloadResult = parseQQBotPayload(replyText);
-
-  if (!payloadResult.isPayload) return false;
-
-  if (payloadResult.error) {
-    log?.error(`[qqbot:${account.accountId}] Payload parse error: ${payloadResult.error}`);
-    return true;
-  }
-
-  if (!payloadResult.payload) return true;
-
-  const parsedPayload = payloadResult.payload;
-  log?.info(`[qqbot:${account.accountId}] Detected structured payload, type: ${parsedPayload.type}`);
-
-  if (isCronReminderPayload(parsedPayload)) {
-    log?.info(`[qqbot:${account.accountId}] Processing cron_reminder payload`);
-    const cronMessage = encodePayloadForCron(parsedPayload);
-    const confirmText = `⏰ 提醒已设置，将在指定时间发送: "${parsedPayload.content}"`;
-    try {
-      await sendTextToTarget(ctx, confirmText);
-      log?.info(`[qqbot:${account.accountId}] Cron reminder confirmation sent, cronMessage: ${cronMessage}`);
-    } catch (err) {
-      log?.error(`[qqbot:${account.accountId}] Failed to send cron confirmation: ${err}`);
-    }
-    recordActivity();
-    return true;
-  }
-
-  if (isMediaPayload(parsedPayload)) {
-    log?.info(`[qqbot:${account.accountId}] Processing media payload, mediaType: ${parsedPayload.mediaType}`);
-
-    if (parsedPayload.mediaType === "image") {
-      await handleImagePayload(ctx, parsedPayload);
-    } else if (parsedPayload.mediaType === "audio") {
-      await handleAudioPayload(ctx, parsedPayload);
-    } else if (parsedPayload.mediaType === "video") {
-      await handleVideoPayload(ctx, parsedPayload);
-    } else if (parsedPayload.mediaType === "file") {
-      await handleFilePayload(ctx, parsedPayload);
-    } else {
-      log?.error(`[qqbot:${account.accountId}] Unknown media type: ${(parsedPayload as MediaPayload).mediaType}`);
-    }
-    recordActivity();
-    return true;
-  }
-
-  log?.error(`[qqbot:${account.accountId}] Unknown payload type: ${(parsedPayload as any).type}`);
-  return true;
-}
-
-// ============ 媒体载荷处理 ============
-
-async function handleImagePayload(ctx: ReplyContext, payload: MediaPayload): Promise<void> {
-  const { target, account, log } = ctx;
-  let imageUrl = normalizePath(payload.path);
-  const originalImagePath = payload.source === "file" ? imageUrl : undefined;
-
-  if (payload.source === "file") {
-    try {
-      if (!(await fileExistsAsync(imageUrl))) {
-        log?.error(`[qqbot:${account.accountId}] Image not found: ${imageUrl}`);
-        return;
-      }
-      const imgSzCheck = checkFileSize(imageUrl, getMaxUploadSize(1)); // IMAGE = 1
-      if (!imgSzCheck.ok) {
-        log?.error(`[qqbot:${account.accountId}] Image size check failed: ${imgSzCheck.error}`);
-        return;
-      }
-      const fileBuffer = await readFileAsync(imageUrl);
-      const base64Data = fileBuffer.toString("base64");
-      const ext = path.extname(imageUrl).toLowerCase();
-      const mimeTypes: Record<string, string> = {
-        ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
-        ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp",
-      };
-      const mimeType = mimeTypes[ext];
-      if (!mimeType) {
-        log?.error(`[qqbot:${account.accountId}] Unsupported image format: ${ext}`);
-        return;
-      }
-      imageUrl = `data:${mimeType};base64,${base64Data}`;
-      log?.info(`[qqbot:${account.accountId}] Converted local image to Base64 (size: ${formatFileSize(fileBuffer.length)})`);
-    } catch (readErr) {
-      log?.error(`[qqbot:${account.accountId}] Failed to read local image: ${readErr}`);
-      return;
-    }
-  }
-
-  try {
-    await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-      if (target.type === "c2c") {
-        await sendC2CImageMessage(token, target.senderId, imageUrl, target.messageId, undefined, originalImagePath);
-      } else if (target.type === "group" && target.groupOpenid) {
-        await sendGroupImageMessage(token, target.groupOpenid, imageUrl, target.messageId);
-      } else if (target.channelId) {
-        await sendChannelMessage(token, target.channelId, `![](${payload.path})`, target.messageId);
-      }
-    }, log, account.accountId);
-    log?.info(`[qqbot:${account.accountId}] Sent image via media payload`);
-
-    if (payload.caption) {
-      await sendTextToTarget(ctx, payload.caption);
-    }
-  } catch (err) {
-    log?.error(`[qqbot:${account.accountId}] Failed to send image: ${err}`);
-  }
-}
-
-async function handleAudioPayload(ctx: ReplyContext, payload: MediaPayload): Promise<void> {
-  const { target, account, cfg, log } = ctx;
-  try {
-    const ttsText = payload.caption || payload.path;
-    if (!ttsText?.trim()) {
-      log?.error(`[qqbot:${account.accountId}] Voice missing text`);
-    } else {
-      const ttsCfg = resolveTTSConfig(cfg as Record<string, unknown>);
-      if (!ttsCfg) {
-        log?.error(`[qqbot:${account.accountId}] TTS not configured (channels.qqbot.tts in openclaw.json)`);
-      } else {
-        log?.info(`[qqbot:${account.accountId}] TTS: "${ttsText.slice(0, 50)}..." via ${ttsCfg.model}`);
-        const ttsDir = getQQBotDataDir("tts");
-        const { silkPath, silkBase64, duration } = await textToSilk(ttsText, ttsCfg, ttsDir);
-        log?.info(`[qqbot:${account.accountId}] TTS done: ${formatDuration(duration)}, file saved: ${silkPath}`);
-
-        await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-          if (target.type === "c2c") {
-            await sendC2CVoiceMessage(token, target.senderId, silkBase64, target.messageId, ttsText, silkPath);
-          } else if (target.type === "group" && target.groupOpenid) {
-            await sendGroupVoiceMessage(token, target.groupOpenid, silkBase64, target.messageId);
-          } else if (target.channelId) {
-            log?.error(`[qqbot:${account.accountId}] Voice not supported in channel, sending text fallback`);
-            await sendChannelMessage(token, target.channelId, ttsText, target.messageId);
-          }
-        }, log, account.accountId);
-        log?.info(`[qqbot:${account.accountId}] Voice message sent`);
-      }
-    }
-  } catch (err) {
-    log?.error(`[qqbot:${account.accountId}] TTS/voice send failed: ${err}`);
-  }
-}
-
-async function handleVideoPayload(ctx: ReplyContext, payload: MediaPayload): Promise<void> {
-  const { target, account, log } = ctx;
-  try {
-    const videoPath = normalizePath(payload.path ?? "");
-    if (!videoPath?.trim()) {
-      log?.error(`[qqbot:${account.accountId}] Video missing path`);
-    } else {
-      const isHttpUrl = videoPath.startsWith("http://") || videoPath.startsWith("https://");
-      log?.info(`[qqbot:${account.accountId}] Video send: "${videoPath.slice(0, 60)}..."`);
-
-      await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-        if (isHttpUrl) {
-          if (target.type === "c2c") {
-            await sendC2CVideoMessage(token, target.senderId, videoPath, undefined, target.messageId);
-          } else if (target.type === "group" && target.groupOpenid) {
-            await sendGroupVideoMessage(token, target.groupOpenid, videoPath, undefined, target.messageId);
-          } else if (target.channelId) {
-            log?.error(`[qqbot:${account.accountId}] Video not supported in channel`);
-          }
-        } else {
-          if (!(await fileExistsAsync(videoPath))) {
-            throw new Error(`视频文件不存在: ${videoPath}`);
-          }
-          const vPaySzCheck = checkFileSize(videoPath, getMaxUploadSize(2)); // VIDEO = 2
-          if (!vPaySzCheck.ok) {
-            throw new Error(vPaySzCheck.error!);
-          }
-          const fileBuffer = await readFileAsync(videoPath);
-          const videoBase64 = fileBuffer.toString("base64");
-          log?.info(`[qqbot:${account.accountId}] Read local video (${formatFileSize(fileBuffer.length)}): ${videoPath}`);
-
-          if (target.type === "c2c") {
-            await sendC2CVideoMessage(token, target.senderId, undefined, videoBase64, target.messageId, undefined, videoPath);
-          } else if (target.type === "group" && target.groupOpenid) {
-            await sendGroupVideoMessage(token, target.groupOpenid, undefined, videoBase64, target.messageId);
-          } else if (target.channelId) {
-            log?.error(`[qqbot:${account.accountId}] Video not supported in channel`);
-          }
-        }
-      }, log, account.accountId);
-      log?.info(`[qqbot:${account.accountId}] Video message sent`);
-
-      if (payload.caption) {
-        await sendTextToTarget(ctx, payload.caption);
-      }
-    }
-  } catch (err) {
-    log?.error(`[qqbot:${account.accountId}] Video send failed: ${err}`);
-  }
-}
-
-async function handleFilePayload(ctx: ReplyContext, payload: MediaPayload): Promise<void> {
-  const { target, account, log } = ctx;
-  try {
-    const filePath = normalizePath(payload.path ?? "");
-    if (!filePath?.trim()) {
-      log?.error(`[qqbot:${account.accountId}] File missing path`);
-    } else {
-      const isHttpUrl = filePath.startsWith("http://") || filePath.startsWith("https://");
-      const fileName = sanitizeFileName(path.basename(filePath));
-      log?.info(`[qqbot:${account.accountId}] File send: "${filePath.slice(0, 60)}..." (${isHttpUrl ? "URL" : "local"})`);
-
-      await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-        if (isHttpUrl) {
-          if (target.type === "c2c") {
-            await sendC2CFileMessage(token, target.senderId, undefined, filePath, target.messageId, fileName);
-          } else if (target.type === "group" && target.groupOpenid) {
-            await sendGroupFileMessage(token, target.groupOpenid, undefined, filePath, target.messageId, fileName);
-          } else if (target.channelId) {
-            log?.error(`[qqbot:${account.accountId}] File not supported in channel`);
-          }
-        } else {
-          if (!(await fileExistsAsync(filePath))) {
-            throw new Error(`文件不存在: ${filePath}`);
-          }
-          const fPaySzCheck = checkFileSize(filePath, getMaxUploadSize(4)); // FILE = 4
-          if (!fPaySzCheck.ok) {
-            throw new Error(fPaySzCheck.error!);
-          }
-          const fileBuffer = await readFileAsync(filePath);
-          const fileBase64 = fileBuffer.toString("base64");
-          if (target.type === "c2c") {
-            await sendC2CFileMessage(token, target.senderId, fileBase64, undefined, target.messageId, fileName, filePath);
-          } else if (target.type === "group" && target.groupOpenid) {
-            await sendGroupFileMessage(token, target.groupOpenid, fileBase64, undefined, target.messageId, fileName);
-          } else if (target.channelId) {
-            log?.error(`[qqbot:${account.accountId}] File not supported in channel`);
-          }
-        }
-      }, log, account.accountId);
-      log?.info(`[qqbot:${account.accountId}] File message sent`);
-    }
-  } catch (err) {
-    log?.error(`[qqbot:${account.accountId}] File send failed: ${err}`);
-  }
-}

package/src/session-store.ts

@@ -1,303 +0,0 @@
-/**
- * Session 持久化存储
- * 将 WebSocket 连接状态（sessionId、lastSeq）持久化到文件
- * 支持进程重启后通过 Resume 机制快速恢复连接
- */
-
-import fs from "node:fs";
-import path from "node:path";
-
-// Session 状态接口
-export interface SessionState {
-  /** WebSocket Session ID */
-  sessionId: string | null;
-  /** 最后收到的消息序号 */
-  lastSeq: number | null;
-  /** 上次连接成功的时间戳 */
-  lastConnectedAt: number;
-  /** 上次成功的权限级别索引 */
-  intentLevelIndex: number;
-  /** 关联的机器人账户 ID */
-  accountId: string;
-  /** 保存时间 */
-  savedAt: number;
-  /** 创建此 session 时使用的 appId（用于检测凭据变更） */
-  appId?: string;
-}
-
-import { getQQBotDataDir } from "./utils/platform.js";
-
-// Session 文件目录
-const SESSION_DIR = getQQBotDataDir("sessions");
-
-// Session 过期时间（5分钟）- Resume 要求在断开后一定时间内恢复
-const SESSION_EXPIRE_TIME = 5 * 60 * 1000;
-
-// 写入节流时间（避免频繁写入）
-const SAVE_THROTTLE_MS = 1000;
-
-// 每个账户的节流状态
-const throttleState = new Map<string, {
-  pendingState: SessionState | null;
-  lastSaveTime: number;
-  throttleTimer: ReturnType<typeof setTimeout> | null;
-}>();
-
-/**
- * 确保目录存在
- */
-function ensureDir(): void {
-  if (!fs.existsSync(SESSION_DIR)) {
-    fs.mkdirSync(SESSION_DIR, { recursive: true });
-  }
-}
-
-/**
- * 获取 Session 文件路径
- */
-function getSessionPath(accountId: string): string {
-  // 清理 accountId 中的特殊字符
-  const safeId = accountId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path.join(SESSION_DIR, `session-${safeId}.json`);
-}
-
-/**
- * 加载 Session 状态
- * @param accountId 账户 ID
- * @param expectedAppId 当前使用的 appId，如果与保存时的 appId 不匹配则视为失效
- * @returns Session 状态，如果不存在、已过期或 appId 不匹配返回 null
- */
-export function loadSession(accountId: string, expectedAppId?: string): SessionState | null {
-  const filePath = getSessionPath(accountId);
-  
-  try {
-    if (!fs.existsSync(filePath)) {
-      return null;
-    }
-    
-    const data = fs.readFileSync(filePath, "utf-8");
-    const state = JSON.parse(data) as SessionState;
-    
-    // 检查是否过期
-    const now = Date.now();
-    if (now - state.savedAt > SESSION_EXPIRE_TIME) {
-      console.log(`[session-store] Session expired for ${accountId}, age: ${Math.round((now - state.savedAt) / 1000)}s`);
-      try {
-        fs.unlinkSync(filePath);
-      } catch {
-        // 忽略删除错误
-      }
-      return null;
-    }
-
-    // 检查 appId 是否匹配（凭据变更检测）
-    if (expectedAppId && state.appId && state.appId !== expectedAppId) {
-      console.log(`[session-store] appId mismatch for ${accountId}: saved=${state.appId}, current=${expectedAppId}. Discarding stale session.`);
-      try {
-        fs.unlinkSync(filePath);
-      } catch {
-        // 忽略删除错误
-      }
-      return null;
-    }
-    
-    // 验证必要字段
-    if (!state.sessionId || state.lastSeq === null || state.lastSeq === undefined) {
-      console.log(`[session-store] Invalid session data for ${accountId}`);
-      return null;
-    }
-    
-    console.log(`[session-store] Loaded session for ${accountId}: sessionId=${state.sessionId}, lastSeq=${state.lastSeq}, appId=${state.appId ?? "unknown"}, age=${Math.round((now - state.savedAt) / 1000)}s`);
-    return state;
-  } catch (err) {
-    console.error(`[session-store] Failed to load session for ${accountId}: ${err}`);
-    return null;
-  }
-}
-
-/**
- * 保存 Session 状态（带节流，避免频繁写入）
- * @param state Session 状态
- */
-export function saveSession(state: SessionState): void {
-  const { accountId } = state;
-  
-  // 获取或初始化节流状态
-  let throttle = throttleState.get(accountId);
-  if (!throttle) {
-    throttle = {
-      pendingState: null,
-      lastSaveTime: 0,
-      throttleTimer: null,
-    };
-    throttleState.set(accountId, throttle);
-  }
-  
-  const now = Date.now();
-  const timeSinceLastSave = now - throttle.lastSaveTime;
-  
-  // 如果距离上次保存时间足够长，立即保存
-  if (timeSinceLastSave >= SAVE_THROTTLE_MS) {
-    doSaveSession(state);
-    throttle.lastSaveTime = now;
-    throttle.pendingState = null;
-    
-    // 清除待定的节流定时器
-    if (throttle.throttleTimer) {
-      clearTimeout(throttle.throttleTimer);
-      throttle.throttleTimer = null;
-    }
-  } else {
-    // 记录待保存的状态
-    throttle.pendingState = state;
-    
-    // 如果没有设置定时器，设置一个
-    if (!throttle.throttleTimer) {
-      const delay = SAVE_THROTTLE_MS - timeSinceLastSave;
-      throttle.throttleTimer = setTimeout(() => {
-        const t = throttleState.get(accountId);
-        if (t && t.pendingState) {
-          doSaveSession(t.pendingState);
-          t.lastSaveTime = Date.now();
-          t.pendingState = null;
-        }
-        if (t) {
-          t.throttleTimer = null;
-        }
-      }, delay);
-    }
-  }
-}
-
-/**
- * 实际执行保存操作
- */
-function doSaveSession(state: SessionState): void {
-  const filePath = getSessionPath(state.accountId);
-  
-  try {
-    ensureDir();
-    
-    // 更新保存时间
-    const stateToSave: SessionState = {
-      ...state,
-      savedAt: Date.now(),
-    };
-    
-    fs.writeFileSync(filePath, JSON.stringify(stateToSave, null, 2), "utf-8");
-    console.log(`[session-store] Saved session for ${state.accountId}: sessionId=${state.sessionId}, lastSeq=${state.lastSeq}`);
-  } catch (err) {
-    console.error(`[session-store] Failed to save session for ${state.accountId}: ${err}`);
-  }
-}
-
-/**
- * 清除 Session 状态
- * @param accountId 账户 ID
- */
-export function clearSession(accountId: string): void {
-  const filePath = getSessionPath(accountId);
-  
-  // 清除节流状态
-  const throttle = throttleState.get(accountId);
-  if (throttle) {
-    if (throttle.throttleTimer) {
-      clearTimeout(throttle.throttleTimer);
-    }
-    throttleState.delete(accountId);
-  }
-  
-  try {
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-      console.log(`[session-store] Cleared session for ${accountId}`);
-    }
-  } catch (err) {
-    console.error(`[session-store] Failed to clear session for ${accountId}: ${err}`);
-  }
-}
-
-/**
- * 更新 lastSeq（轻量级更新）
- * @param accountId 账户 ID
- * @param lastSeq 最新的消息序号
- */
-export function updateLastSeq(accountId: string, lastSeq: number): void {
-  const existing = loadSession(accountId);
-  if (existing && existing.sessionId) {
-    saveSession({
-      ...existing,
-      lastSeq,
-    });
-  }
-}
-
-/**
- * 获取所有保存的 Session 状态
- */
-export function getAllSessions(): SessionState[] {
-  const sessions: SessionState[] = [];
-  
-  try {
-    ensureDir();
-    const files = fs.readdirSync(SESSION_DIR);
-    
-    for (const file of files) {
-      if (file.startsWith("session-") && file.endsWith(".json")) {
-        const filePath = path.join(SESSION_DIR, file);
-        try {
-          const data = fs.readFileSync(filePath, "utf-8");
-          const state = JSON.parse(data) as SessionState;
-          sessions.push(state);
-        } catch {
-          // 忽略解析错误
-        }
-      }
-    }
-  } catch {
-    // 目录不存在等错误
-  }
-  
-  return sessions;
-}
-
-/**
- * 清理过期的 Session 文件
- */
-export function cleanupExpiredSessions(): number {
-  let cleaned = 0;
-  
-  try {
-    ensureDir();
-    const files = fs.readdirSync(SESSION_DIR);
-    const now = Date.now();
-    
-    for (const file of files) {
-      if (file.startsWith("session-") && file.endsWith(".json")) {
-        const filePath = path.join(SESSION_DIR, file);
-        try {
-          const data = fs.readFileSync(filePath, "utf-8");
-          const state = JSON.parse(data) as SessionState;
-          
-          if (now - state.savedAt > SESSION_EXPIRE_TIME) {
-            fs.unlinkSync(filePath);
-            cleaned++;
-            console.log(`[session-store] Cleaned expired session: ${file}`);
-          }
-        } catch {
-          // 忽略解析错误，但也删除损坏的文件
-          try {
-            fs.unlinkSync(filePath);
-            cleaned++;
-          } catch {
-            // 忽略
-          }
-        }
-      }
-    }
-  } catch {
-    // 目录不存在等错误
-  }
-  
-  return cleaned;
-}