koishi-plugin-kkk 1.0.0

package/lib/karin/platform/douyin/getID.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDouyinID = void 0;
+const node_karin_1 = require("../../../compat/node-karin.js");
+const axios_1 = __importDefault(require("../../../compat/axios.js"));
+const workType_1 = require("./workType");
+/**
+ * 获取抖音作品ID
+ * @param event 消息事件
+ * @param url 分享链接
+ * @param log 输出日志，默认true
+ * @returns
+ */
+const getDouyinID = async (event, url, log = true) => {
+    const resp = await axios_1.default.get(url, {
+        headers: {
+            'User-Agent': 'Apifox/1.0.0 (https://apifox.com)'
+        },
+        maxRedirects: 10 // 确保跟随所有重定向
+    });
+    // 使用 responseUrl 或 request.res.responseUrl 获取最终 URL
+    const longLink = resp.request?.res?.responseUrl || resp.request?.responseURL || url;
+    let result = {};
+    switch (true) {
+        case longLink.includes('webcast.amemv.com'):
+        case longLink.includes('live.douyin.com'): {
+            if (longLink.includes('webcast.amemv.com')) {
+                const sec_uid = /sec_user_id=([^&]+)/.exec(longLink);
+                result = {
+                    type: 'live_room_detail',
+                    sec_uid: sec_uid ? sec_uid[1] : undefined
+                };
+            }
+            else if (longLink.includes('live.douyin.com')) {
+                result = {
+                    type: 'live_room_detail',
+                    room_id: longLink.split('/').pop()
+                };
+            }
+            break;
+        }
+        case /video\/(\d+)/.test(longLink):
+        case /article\/(\d+)/.test(longLink):
+        case /note\/(\d+)/.test(longLink): {
+            // 统一处理 video/article/note 类型，不在这里判断具体类型
+            // 因为抖音会先重定向到 /video/ 再通过 JS 跳转到 /article/
+            // 具体类型由后续 API 返回的 aweme_type 字段决定
+            const match = /(?:video|article|note)\/(\d+)/.exec(longLink);
+            result = {
+                type: 'one_work',
+                aweme_id: match ? match[1] : undefined
+                // 暂不设置 is_mp4 和 work_type，由后续 API 数据决定
+            };
+            break;
+        }
+        case /modal_id=(\d+)/.test(longLink): {
+            const modalMatch = /modal_id=(\d+)/.exec(longLink);
+            result = {
+                type: 'one_work',
+                aweme_id: modalMatch ? modalMatch[1] : undefined,
+                is_mp4: true,
+                work_type: workType_1.DouyinWorkMainType.VIDEO
+            };
+            break;
+        }
+        case /https:\/\/(?:www\.douyin\.com|www\.iesdouyin\.com)\/(?:share\/)?user\/(\S+)/.test(longLink): {
+            const userMatch = /user\/([a-zA-Z0-9_-]+)/.exec(longLink);
+            result = {
+                type: 'user_dynamic',
+                sec_uid: userMatch ? userMatch[1] : undefined
+            };
+            break;
+        }
+        case /music\/(\d+)/.test(longLink): {
+            const musicMatch = /music\/(\d+)/.exec(longLink);
+            result = {
+                type: 'music_work',
+                music_id: musicMatch ? musicMatch[1] : undefined
+            };
+            break;
+        }
+        default:
+            node_karin_1.logger.warn('无法获取作品ID');
+            break;
+    }
+    if (log) {
+        console.log(result);
+    }
+    return result;
+};
+exports.getDouyinID = getDouyinID;

package/lib/karin/platform/douyin/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./comments"), exports);
+__exportStar(require("./danmaku"), exports);
+__exportStar(require("./douyin"), exports);
+__exportStar(require("./getID"), exports);
+// export * from './login.ts.bak'
+__exportStar(require("./push"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./videoQuality"), exports);

package/lib/karin/platform/douyin/login.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.douyinLogin = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_karin_1 = require("../../../compat/node-karin.js");
+const module_1 = require("../../module");
+const amagiClient_1 = require("../../module/utils/amagiClient");
+const bot_1 = require("../../module/utils/bot");
+const Config_1 = require("../../module/utils/Config");
+/** 等待用户扫码的时限上限，与消息可撤回窗口（2 分钟）对齐 */
+const SCAN_TIMEOUT = 120_000;
+/** 扫码后等待手机确认或完成二次验证的时限 */
+const CONFIRM_TIMEOUT = 180_000;
+/** 等待用户回填短信验证码的时限（秒） */
+const CODE_INPUT_TIMEOUT = 90;
+/** 短信验证码允许的重试次数 */
+const CODE_MAX_ATTEMPTS = 3;
+/** 6 位数字验证码 */
+const CODE_PATTERN = /^\d{6}$/;
+/** 登录凭证里需要确认下发的关键 cookie */
+const REQUIRED_COOKIES = ['sessionid', 'sessionid_ss', 'sid_guard', 'uid_tt', 'uid_tt_ss', 'ttwid'];
+/**
+ * 主动中断登录会话。
+ *
+ * v7 的 `watch` 只在**调用方回调自己抛出**时才 reject，所以从 `onChallenge`
+ * 里退出流程只能靠抛 —— 回调的返回类型是 `{ code: string }`，没有「放弃」这个取值。
+ * 用一个专门的异常带上要发给用户的话，外层认出它就正常收尾。
+ */
+class LoginAborted extends Error {
+    notice;
+    constructor(notice) {
+        super(notice);
+        this.notice = notice;
+        this.name = 'LoginAborted';
+    }
+}
+/**
+ * 登录过程中发出的消息，全部登记在这里，结束时统一撤回，避免二维码留在群里
+ * @param e - 消息事件
+ * @returns 带 send / recallAll 的登记器
+ */
+const createMessageTracker = (e) => {
+    const messageIds = [];
+    return {
+        /**
+         * 发送并登记一条消息
+         * @param message - 消息内容
+         * @returns 发送结果
+         */
+        async send(message) {
+            const sent = await e.reply(message, { reply: true });
+            if (sent.messageId)
+                messageIds.push(sent.messageId);
+            return sent;
+        },
+        /** 撤回目前登记的全部消息 */
+        async recallAll() {
+            const pending = messageIds.splice(0, messageIds.length);
+            await Promise.all(pending.map(async (id) => {
+                try {
+                    await e.bot.recallMsg(e.contact, id);
+                }
+                catch (error) {
+                    node_karin_1.logger.debug('[抖音登录] 撤回消息失败:', error);
+                }
+            }));
+        }
+    };
+};
+/**
+ * 渲染并发送登录二维码，同时落一份到临时目录方便排查。
+ * @param e - 消息事件
+ * @param qrcode - 会话给出的二维码
+ * @param tracker - 消息登记器
+ */
+const sendQrcode = async (e, qrcode, tracker) => {
+    const rendered = await (0, module_1.Render)(e, 'douyin/qrcodeImg', {
+        share_url: qrcode.content,
+        avatarUrl: await (0, bot_1.resolveTriggerAvatarUrl)(e)
+    });
+    const base64Data = rendered[0]?.file;
+    if (!base64Data)
+        throw new Error('生成二维码图片失败');
+    node_fs_1.default.writeFileSync(`${module_1.Common.tempDri.default}DouyinLoginQrcode.png`, Buffer.from(base64Data.replace(/^base64:\/\//, ''), 'base64'));
+    await tracker.send(rendered);
+};
+/**
+ * 处理短信二次验证：发码 → 等用户回填 → 交回会话。
+ *
+ * 发码由 `challenge.sendCode()` 负责，验码由会话的 `answer` 负责（本函数只把
+ * 6 位码取回来）—— `biz_trace_id` 与 `verify_way` 由 amagi 的会话自己串，
+ * v6 时代要调用方在两次请求之间原样传回的隐式契约没有了。
+ * @param e - 消息事件
+ * @param challenge - 会话给出的短信 challenge
+ * @param tracker - 消息登记器
+ * @returns 用户回填的 6 位验证码
+ * @throws {LoginAborted} 用户超时、格式错误用尽次数或发码失败
+ */
+const collectSmsCode = async (e, challenge, tracker) => {
+    const sent = await challenge.sendCode();
+    if (!sent.ok) {
+        node_karin_1.logger.warn(`[抖音登录] 短信验证码发送失败: ${sent.error.message}`);
+        throw new LoginAborted(`短信验证码发送失败：${sent.error.message}`);
+    }
+    node_karin_1.logger.mark(`[抖音登录] 二次验证可选方式: ${challenge.availableWays.join('、') || '(服务端未给出)'}`);
+    const target = challenge.maskedMobile || '扫码设备绑定的手机号';
+    await tracker.send(`此次登录需要二次验证\n6 位数验证码已发送至 ${target}\n请在 ${CODE_INPUT_TIMEOUT} 秒内直接回复该验证码`);
+    for (let attempt = 1; attempt <= CODE_MAX_ATTEMPTS; attempt++) {
+        const context = await node_karin_1.karin.ctx(e, { time: CODE_INPUT_TIMEOUT, reply: false, throwOnTimeout: false });
+        if (!context)
+            throw new LoginAborted('等待验证码超时，登录已取消');
+        const code = context.msg.trim();
+        if (CODE_PATTERN.test(code))
+            return code;
+        if (attempt === CODE_MAX_ATTEMPTS)
+            throw new LoginAborted('输入格式不正确，登录已取消');
+        await tracker.send(`请只发送 6 位数字验证码（剩余 ${CODE_MAX_ATTEMPTS - attempt} 次机会）`);
+    }
+    throw new LoginAborted('验证码校验未通过，登录已取消');
+};
+/**
+ * 保存登录凭证并重载 Amagi 客户端
+ * @param cookie - 完整登录 cookie
+ */
+const persistCookie = async (cookie) => {
+    const present = new Set(cookie.split(';').map((pair) => pair.split('=')[0].trim()));
+    const missing = REQUIRED_COOKIES.filter((name) => !present.has(name));
+    if (missing.length > 0) {
+        node_karin_1.logger.warn(`[抖音登录] 以下 cookie 未在本次登录中下发：${missing.join(', ')}`);
+    }
+    await Config_1.Config.Modify('amagi', 'cookies.douyin', cookie);
+    // 同步一份到 koishi.yml，控制台表单里也能看到（与 B站登录 一致）
+    const synced = await (0, node_karin_1.syncUpstreamToKoishi)({ amagi: { cookies: { douyin: cookie } } });
+    const reloaded = (0, amagiClient_1.reloadAmagiConfig)();
+    node_karin_1.logger.mark(`[抖音登录] 登录凭证已保存${synced ? '（已同步到控制台配置）' : ''}，Amagi Client ${reloaded ? '已重载' : '配置未变化'}`);
+};
+/** 把会话的失败原因翻成给用户看的话 */
+const noticeOf = (error) => {
+    if (error.kind === 'risk')
+        return `登录请求被抖音风控拦截：${error.message}\n请稍后再试`;
+    if (error.code === 'COOKIE_EXPIRED')
+        return '二维码已失效，请重新发起登录';
+    return `登录未完成：${error.message}`;
+};
+/**
+ * 抖音扫码登录。
+ *
+ * 协议与轮询编排都在 amagi 的 v7 登录会话里（`client.douyin.login.qrcode()`）：
+ * 取码、轮询、退避、限频加倍、challenge 编排、`expire_time` 秒转毫秒全由引擎负责。
+ * 这里只做三件与用户交互的事 —— 渲染二维码、收短信验证码、把凭证落库。
+ * @param e - 消息事件
+ * @returns 固定 true，交回命令框架
+ */
+const douyinLogin = async (e) => {
+    const tracker = createMessageTracker(e);
+    const controller = new AbortController();
+    /** 自己中断时要发的话；有值说明不是引擎给出的失败 */
+    let abortNotice;
+    let scanned = false;
+    let scanTimer;
+    try {
+        const session = (0, amagiClient_1.getAmagiClient)().douyin.login.qrcode();
+        const outcome = await session.watch({
+            signal: controller.signal,
+            // 引擎的超时只在 start 时算一次，没法在扫码后延长；这里给到「等扫码 + 等确认」
+            // 的总量，未扫码的提前退出交给下面的 scanTimer，真正的失效仍以服务端的
+            // expired 状态为准（二维码实际只有约 60 秒）
+            timeoutMs: SCAN_TIMEOUT + CONFIRM_TIMEOUT,
+            onQrcode: async (qrcode) => {
+                node_karin_1.logger.mark(`[抖音登录] 二维码已获取，有效期 ${qrcode.expiresInSec} 秒`);
+                await sendQrcode(e, qrcode, tracker);
+                scanTimer = setTimeout(() => {
+                    if (scanned)
+                        return;
+                    abortNotice = '登录超时！二维码已失效！';
+                    controller.abort();
+                }, SCAN_TIMEOUT);
+            },
+            onScanned: async () => {
+                if (scanned)
+                    return;
+                scanned = true;
+                clearTimeout(scanTimer);
+                await tracker.recallAll();
+                await tracker.send('二维码已扫描，请在手机上确认登录');
+            },
+            // 回调签名是泛型的（返回值形状由 challenge.kind 决定），这里只支持短信一路，
+            // 断言收口到那一支；图形验证码走 LoginAborted 退出
+            onChallenge: (async (challenge) => {
+                scanned = true;
+                clearTimeout(scanTimer);
+                if (challenge.kind !== 'sms') {
+                    throw new LoginAborted('账号触发了图形验证码，当前仅支持短信验证码');
+                }
+                return { code: await collectSmsCode(e, challenge, tracker) };
+            }),
+            onSuccess: async (credential) => {
+                await persistCookie(credential.cookie);
+            }
+        });
+        await tracker.recallAll();
+        if (outcome.ok) {
+            await e.reply('登录成功！用户登录凭证已保存至配置', { reply: true });
+            return true;
+        }
+        if (abortNotice) {
+            await e.reply(abortNotice, { reply: true });
+            return true;
+        }
+        node_karin_1.logger.warn(`[抖音登录] 会话结束于失败态: kind=${outcome.error.kind} code=${outcome.error.code}`);
+        await e.reply(noticeOf(outcome.error), { reply: true });
+    }
+    catch (error) {
+        await tracker.recallAll();
+        if (error instanceof LoginAborted) {
+            await e.reply(error.notice, { reply: true });
+            return true;
+        }
+        node_karin_1.logger.error('[抖音登录] 登录流程出错:', error);
+        await e.reply('登录过程出错，请查看控制台日志', { reply: true });
+    }
+    finally {
+        clearTimeout(scanTimer);
+    }
+    return true;
+};
+exports.douyinLogin = douyinLogin;

package/lib/karin/platform/douyin/push/favorite.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFavoriteList = processFavoriteList;
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const module_1 = require("../../../module");
+const amagiClient_1 = require("../../../module/utils/amagiClient");
+const types_1 = require("../../../platform/douyin/types");
+/**
+ * 处理喜欢列表推送
+ * 通过对比aweme_id判断是否有新增的喜欢作品
+ * @returns 返回需要推送的作品项数组
+ */
+async function processFavoriteList(contentList, sec_uid, userinfo, item, targets, force = false) {
+    const pushType = 'favorite';
+    const listName = '喜欢列表';
+    const result = [];
+    // 获取所有目标群组的历史状态
+    const groupHistoryStatus = new Map();
+    for (const target of targets) {
+        const hasHistory = await module_1.douyinDB.hasHistory(sec_uid, target.groupId, pushType);
+        groupHistoryStatus.set(target.groupId, hasHistory);
+    }
+    for (const [index, aweme] of contentList.entries()) {
+        // 过滤掉已经推送过的群组
+        const validTargets = [];
+        for (const target of targets) {
+            const isPushed = await module_1.douyinDB.isAwemePushed(aweme.aweme_id, sec_uid, target.groupId, pushType);
+            if (!isPushed) {
+                const hasHistory = groupHistoryStatus.get(target.groupId);
+                // 如果是强制推送、老订阅者（有历史记录），或者这是最新的一条作品（index === 0），则推送
+                if (force || hasHistory || index === 0) {
+                    validTargets.push(target);
+                }
+                else {
+                    // 如果是新订阅者且不是最新作品，则不推送，但写入缓存避免下次重复推送
+                    await module_1.douyinDB.addAwemeCache(aweme.aweme_id, sec_uid, target.groupId, pushType);
+                    node_karin_1.logger.debug(`新订阅群组 ${target.groupId} 跳过旧作品 ${aweme.aweme_id} 并已标记为已读`);
+                }
+            }
+        }
+        // 如果所有群组都已推送过（或被跳过），则跳过
+        if (validTargets.length === 0) {
+            continue;
+        }
+        // 获取作品作者的用户信息
+        let authorUserInfo;
+        try {
+            if (aweme.author?.sec_uid) {
+                authorUserInfo = (await amagiClient_1.douyinFetcher.fetchUserProfile({
+                    sec_uid: aweme.author.sec_uid
+                })).data;
+                node_karin_1.logger.debug(`获取作品作者 ${aweme.author.nickname} 的用户信息成功`);
+            }
+        }
+        catch (error) {
+            node_karin_1.logger.warn(`获取作品作者用户信息失败: ${error}`);
+        }
+        // 新增的作品，需要推送
+        result.push({
+            remark: item.remark,
+            sec_uid,
+            create_time: aweme.create_time,
+            targets: validTargets,
+            pushType,
+            // user_info 是点赞者（订阅者）的信息，author_user_info 是作品作者的信息
+            Detail_Data: (0, types_1.buildDouyinWorkDetail)(aweme, { user_info: userinfo, author_user_info: authorUserInfo }),
+            avatar_img: 'https://p3-pc.douyinpic.com/aweme/1080x1080/' + userinfo.user.avatar_larger.uri,
+            living: false
+        });
+        node_karin_1.logger.debug(`发现新${listName}作品：${aweme.aweme_id}`);
+    }
+    // 更新列表快照
+    await module_1.douyinDB.updateListSnapshot(sec_uid, pushType, contentList.map((a) => a.aweme_id));
+    return result;
+}

package/lib/karin/platform/douyin/push/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./favorite"), exports);
+__exportStar(require("./live"), exports);
+__exportStar(require("./post"), exports);
+__exportStar(require("./recommend"), exports);
+__exportStar(require("./types"), exports);

package/lib/karin/platform/douyin/push/live.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLiveStream = processLiveStream;
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const module_1 = require("../../../module");
+/**
+ * 处理直播推送
+ * 检测用户是否开播，如果开播则推送
+ * @returns 返回需要推送的直播项（如果有）
+ */
+async function processLiveStream(sec_uid, userinfo, item, targets, amagi) {
+    // 获取缓存的直播状态
+    const liveStatus = await module_1.douyinDB.getLiveStatus(sec_uid);
+    // 检查用户是否正在直播
+    if (userinfo.user.live_status === 1) {
+        // 生成类型里 `room_data` 是可选的：进推送详情前先确认订阅者那一份也在，
+        // 否则下面拼 Detail_Data 时会 JSON.parse(undefined)
+        const userRoomData = userinfo.user.room_data;
+        if (!userRoomData) {
+            node_karin_1.logger.error('未获取到直播间信息！');
+            return null;
+        }
+        const UserInfoData = await amagi.douyin.fetcher.fetchUserProfile({
+            sec_uid: userinfo.user.sec_uid
+        });
+        if (!UserInfoData.data.user?.live_status || UserInfoData.data.user.live_status !== 1) {
+            node_karin_1.logger.error((UserInfoData?.data?.user?.nickname ?? '用户') + '当前未在直播');
+            return null;
+        }
+        if (!UserInfoData.data.user.room_data) {
+            node_karin_1.logger.error('未获取到直播间信息！');
+            return null;
+        }
+        const room_data = JSON.parse(UserInfoData.data.user.room_data);
+        const liveInfo = await amagi.douyin.fetcher.fetchLiveRoomInfo({
+            room_id: UserInfoData.data.user.room_id_str,
+            web_rid: room_data.owner.web_rid
+        });
+        // 如果之前没有直播，现在开播了，需要推送
+        if (!liveStatus.living) {
+            node_karin_1.logger.info(`用户 ${item.remark ?? sec_uid} 开播了`);
+            return {
+                remark: item.remark,
+                sec_uid,
+                create_time: Date.now(),
+                targets,
+                pushType: 'live',
+                Detail_Data: {
+                    user_info: userinfo,
+                    room_data: JSON.parse(userRoomData),
+                    live_data: liveInfo.data,
+                    liveStatus: {
+                        liveStatus: 'open',
+                        isChanged: true,
+                        isliving: true
+                    }
+                },
+                avatar_img: 'https://p3-pc.douyinpic.com/aweme/1080x1080/' + userinfo.user.avatar_larger.uri,
+                living: true
+            };
+        }
+    }
+    else if (liveStatus.living) {
+        // 如果之前在直播，现在已经关播，需要更新状态
+        await module_1.douyinDB.updateLiveStatus(sec_uid, false);
+        node_karin_1.logger.info(`用户 ${item.remark ?? sec_uid} 已关播，更新直播状态`);
+    }
+    return null;
+}

package/lib/karin/platform/douyin/push/post.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPostList = processPostList;
+const date_fns_1 = require("date-fns");
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const module_1 = require("../../../module");
+const types_1 = require("../../../platform/douyin/types");
+/**
+ * 处理作品列表推送
+ * 按照作品发布时间进行过滤，只推送24小时内的作品
+ * @returns 返回需要推送的作品项数组
+ */
+async function processPostList(contentList, sec_uid, userinfo, item, targets) {
+    const pushType = 'post';
+    const listName = '作品列表';
+    const result = [];
+    for (const aweme of contentList) {
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const createTime = aweme.create_time;
+        const timeDifference = nowSeconds - createTime;
+        const is_top = aweme.is_top === 1;
+        const timeDiffHours = Math.round((timeDifference / 3600) * 100) / 100;
+        node_karin_1.logger.trace(`
+      前期获取该作品基本信息：
+      推送类型：${pushType}（${listName}）
+      作者：${aweme.author.nickname}
+      作品ID：${aweme.aweme_id}
+      发布时间：${(0, date_fns_1.format)((0, date_fns_1.fromUnixTime)(aweme.create_time), 'yyyy-MM-dd HH:mm')}
+      发布时间戳（s）：${createTime}
+      当前时间戳（s）：${nowSeconds}
+      时间差（s）：${timeDifference}s (${timeDiffHours}h)
+      是否置顶：${is_top}
+      是否在一天内：${timeDifference < 86400 ? node_karin_1.logger.green('true') : node_karin_1.logger.red('false')}
+      `);
+        // 判断是否需要推送（86400秒 = 1天）
+        if ((is_top && timeDifference < 86400) || (timeDifference < 86400 && !is_top)) {
+            // 过滤掉已经推送过的群组
+            const validTargets = [];
+            for (const target of targets) {
+                const isPushed = await module_1.douyinDB.isAwemePushed(aweme.aweme_id, sec_uid, target.groupId, pushType);
+                if (!isPushed) {
+                    validTargets.push(target);
+                }
+            }
+            if (validTargets.length > 0) {
+                result.push({
+                    remark: item.remark,
+                    sec_uid,
+                    create_time: aweme.create_time,
+                    targets: validTargets,
+                    pushType,
+                    Detail_Data: (0, types_1.buildDouyinWorkDetail)(aweme, { user_info: userinfo }),
+                    avatar_img: 'https://p3-pc.douyinpic.com/aweme/1080x1080/' + userinfo.user.avatar_larger.uri,
+                    living: false
+                });
+            }
+        }
+    }
+    return result;
+}

package/lib/karin/platform/douyin/push/recommend.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRecommendList = processRecommendList;
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const module_1 = require("../../../module");
+const amagiClient_1 = require("../../../module/utils/amagiClient");
+const types_1 = require("../../../platform/douyin/types");
+/**
+ * 处理推荐列表推送
+ * 通过对比aweme_id判断是否有新增的推荐作品
+ * @returns 返回需要推送的作品项数组
+ */
+async function processRecommendList(contentList, sec_uid, userinfo, item, targets, force = false) {
+    const pushType = 'recommend';
+    const listName = '推荐列表';
+    const result = [];
+    // 获取所有目标群组的历史状态
+    const groupHistoryStatus = new Map();
+    for (const target of targets) {
+        const hasHistory = await module_1.douyinDB.hasHistory(sec_uid, target.groupId, pushType);
+        groupHistoryStatus.set(target.groupId, hasHistory);
+    }
+    for (const [index, aweme] of contentList.entries()) {
+        // 过滤掉已经推送过的群组
+        const validTargets = [];
+        for (const target of targets) {
+            const isPushed = await module_1.douyinDB.isAwemePushed(aweme.aweme_id, sec_uid, target.groupId, pushType);
+            if (!isPushed) {
+                const hasHistory = groupHistoryStatus.get(target.groupId);
+                // 如果是强制推送、老订阅者（有历史记录），或者这是最新的一条作品（index === 0），则推送
+                if (force || hasHistory || index === 0) {
+                    validTargets.push(target);
+                }
+                else {
+                    // 如果是新订阅者且不是最新作品，则不推送，但写入缓存避免下次重复推送
+                    await module_1.douyinDB.addAwemeCache(aweme.aweme_id, sec_uid, target.groupId, pushType);
+                    node_karin_1.logger.debug(`新订阅群组 ${target.groupId} 跳过旧作品 ${aweme.aweme_id} 并已标记为已读`);
+                }
+            }
+        }
+        // 如果所有群组都已推送过（或被跳过），则跳过
+        if (validTargets.length === 0) {
+            continue;
+        }
+        // 获取作品作者的用户信息
+        let authorUserInfo;
+        try {
+            if (aweme.author?.sec_uid) {
+                authorUserInfo = (await amagiClient_1.douyinFetcher.fetchUserProfile({
+                    sec_uid: aweme.author.sec_uid
+                })).data;
+                node_karin_1.logger.debug(`获取作品作者 ${aweme.author.nickname} 的用户信息成功`);
+            }
+        }
+        catch (error) {
+            node_karin_1.logger.warn(`获取作品作者用户信息失败: ${error}`);
+        }
+        // 新增的作品，需要推送
+        result.push({
+            remark: item.remark,
+            sec_uid,
+            create_time: aweme.create_time,
+            targets: validTargets,
+            pushType,
+            Detail_Data: (0, types_1.buildDouyinWorkDetail)(aweme, { user_info: userinfo, author_user_info: authorUserInfo }),
+            avatar_img: 'https://p3-pc.douyinpic.com/aweme/1080x1080/' + userinfo.user.avatar_larger.uri,
+            living: false
+        });
+        node_karin_1.logger.debug(`发现新${listName}作品：${aweme.aweme_id}`);
+    }
+    // 更新列表快照
+    await module_1.douyinDB.updateListSnapshot(sec_uid, pushType, contentList.map((a) => a.aweme_id));
+    return result;
+}