fmodeagent-push-watch.js 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491
  1. // fmodeagent-push-watch —— 任务完成后把结果推给用户(v1.0.0 · 2026-11-22 重写)
  2. //
  3. // ============ 一句话 ============
  4. //
  5. // **只在「这一轮任务全部完成」时推一条**,不推过程、不推中间消息。
  6. //
  7. // ============ 触发源:容器主动发的回合完成事件 ============
  8. //
  9. // 容器在每轮任务结束时(正文发完之后)往房间写一个事件:
  10. //
  11. // type: com.fmode.turn_status
  12. // content: { sessionKey: "<roomId>", status: "running" | "idle" }
  13. //
  14. // `status: "idle"` 就是「这轮完了」——这是容器自己给的结论,服务端**不需要**
  15. // 去猜消息发到哪、也不需要定时轮询。
  16. //
  17. // 原先的实现是「每 30–60 秒轮询所有用户房间、有新消息就推」,那是错的:
  18. // · 要平台配定时任务;
  19. // · 一轮任务会产生十几条工具调用消息 → 推十几条;
  20. // · 判断不了「任务完成」,只能按消息逐条推。
  21. // 现在改为**按事件触发**,一次任务 = 一条推送。
  22. //
  23. // ============ 调用方式 ============
  24. //
  25. // 由「谁检测到 idle 就调一次」——调用方持服务端凭据:
  26. //
  27. // POST https://server.fmode.cn/api/functions
  28. // X-Parse-Application-Id: ncloudmaster
  29. // X-Fmode-Push-Token: <SERVER_TOKEN>
  30. // { "id": "<本函数 objectId>", params: { userId?, roomIds?: [...] } }
  31. //
  32. // · 不传参数 → 扫描所有绑定用户的房间,找「刚完成」的回合
  33. // · 传 userId / roomIds → 只检查这些目标(推荐,范围明确)
  34. //
  35. // 安全:没有任何匿名放行分支。服务端凭据只在本文件与本函数内。
  36. //
  37. // 版本 v1.0.0 · 2026-11-22
  38. var MATRIX_HS = 'https://matrix.fmode.cn';
  39. var MATRIX_DOMAIN = 'fmode.cn';
  40. var PUSH_FN_ID = 'oCRJCCdiAx'; // fmodeagent-push(同目录)
  41. var FUNCTIONS_URL = 'https://server.fmode.cn/api/functions';
  42. var SERVER_TOKEN = 'fmpush-srv-2026-11-c33a9e71';
  43. var CURSOR_CLASS = 'FmodePushCursor'; // 每个房间已处理到哪个事件
  44. var LOG_CLASS = 'FmodePushLog'; // 已推送过的回合(去重)
  45. var MAX_USERS = 50;
  46. var PER_ROOM_LIMIT = 30; // 单房间回看多少条事件
  47. /** 游标有效性起点:早于此刻的游标视为历史遗留,不参与筛选 */
  48. var CURSOR_EPOCH = 0; // 已废弃:改用「游标是否落后于最新事件」判定
  49. /** 静默时段(服务器本地时区小时数):[quietStart, quietEnd) */
  50. var QUIET_START = 23;
  51. var QUIET_END = 8;
  52. function _fail(code, mess) { response.status(code).json({ code: code, mess: mess }); }
  53. function _ok(data) { response.status(200).json(Object.assign({ code: 200 }, data)); }
  54. /** 服务端凭据:只认 X-Fmode-Push-Token(或 body 里的 cronKey),没有匿名分支 */
  55. function _serverKey() {
  56. var h = (request && request.headers) || {};
  57. if (h['x-fmode-push-token']) return h['x-fmode-push-token'];
  58. if (params && params.serverToken) return params.serverToken;
  59. if (params && params.cronKey) return params.cronKey;
  60. return null;
  61. }
  62. function _httpJson(url, opts) {
  63. return new Promise(function (resolve) {
  64. try {
  65. if (typeof fetch !== 'function') { resolve({ ok: false, err: 'no fetch' }); return; }
  66. var ctrl = typeof AbortController === 'function' ? new AbortController() : null;
  67. var t = ctrl ? setTimeout(function () { try { ctrl.abort(); } catch (e) {} }, 12000) : null;
  68. var init = { method: (opts && opts.method) || 'GET', headers: (opts && opts.headers) || {} };
  69. if (ctrl) init.signal = ctrl.signal;
  70. if (opts && opts.body !== undefined) init.body = JSON.stringify(opts.body);
  71. fetch(url, init).then(function (res) {
  72. return res.text().then(function (txt) {
  73. if (t) clearTimeout(t);
  74. var data = null;
  75. try { data = JSON.parse(txt); } catch (e) { data = { raw: String(txt).slice(0, 300) }; }
  76. resolve({ ok: res.status >= 200 && res.status < 300, status: res.status, data: data });
  77. });
  78. }).catch(function (e) { if (t) clearTimeout(t); resolve({ ok: false, err: String(e) }); });
  79. } catch (e) { resolve({ ok: false, err: String(e) }); }
  80. });
  81. }
  82. function _mxGet(token, path) {
  83. var url = MATRIX_HS + path;
  84. url += (url.indexOf('?') >= 0 ? '&' : '?') + 'access_token=' + encodeURIComponent(token);
  85. return _httpJson(url, { method: 'GET' });
  86. }
  87. function _inQuietHours() {
  88. var h = new Date().getHours();
  89. return QUIET_START > QUIET_END ? (h >= QUIET_START || h < QUIET_END) : (h >= QUIET_START && h < QUIET_END);
  90. }
  91. function _truncate(s, n) {
  92. s = String(s || '').replace(/\s+/g, ' ').trim();
  93. return s.length <= n ? s : s.slice(0, n - 1) + '…';
  94. }
  95. /**
  96. * 是不是「回合完成」事件。
  97. *
  98. * 容器约定:`com.fmode.turn_status` + `status: "idle"`。
  99. * 同时兼容 `m.room.message` 里带 `fmode.turn_status` 的兜底写法。
  100. */
  101. function _isTurnIdle(ev) {
  102. if (!ev) return false;
  103. var c = ev.content || {};
  104. var payload = null;
  105. if (ev.type === 'com.fmode.turn_status') payload = c;
  106. else if (ev.type === 'm.room.message' && c['fmode.turn_status']) payload = c['fmode.turn_status'];
  107. if (!payload) return false;
  108. return String(payload.status || '') === 'idle';
  109. }
  110. /** 从一轮消息里提取「这一轮说了什么」,用于通知正文 */
  111. function _summaryOfEvents(events) {
  112. var texts = [];
  113. for (var i = 0; i < events.length; i++) {
  114. var ev = events[i];
  115. if (!ev || ev.type !== 'm.room.message') continue;
  116. var c = ev.content || {};
  117. if (c['fmode.turn_status']) continue; // 状态型,不算正文
  118. var body = typeof c.body === 'string' ? c.body : '';
  119. if (!body) continue;
  120. var t = body.trim();
  121. // 工具调用碎片不进摘要
  122. if (t.indexOf('💻') === 0 || t.indexOf('$ ') === 0) continue;
  123. if (t.indexOf('```') === 0) continue;
  124. texts.push(t);
  125. }
  126. if (!texts.length) return '';
  127. // 取最后一段实质内容作为摘要(容器通常是「结论在最后」)
  128. return _truncate(texts[texts.length - 1], 120);
  129. }
  130. async function _alreadyPushed(key) {
  131. try {
  132. var q = new Parse.Query(LOG_CLASS);
  133. q.equalTo('eventId', key);
  134. q.limit(1);
  135. var r = await q.find({ useMasterKey: true });
  136. return r.length > 0;
  137. } catch (e) { return false; }
  138. }
  139. async function _markPushed(key, userId, alias, msgId) {
  140. try {
  141. var O = Parse.Object.extend(LOG_CLASS);
  142. var o = new O();
  143. o.set('eventId', key);
  144. o.set('userId', userId);
  145. o.set('alias', alias);
  146. o.set('msgId', msgId || '');
  147. o.set('pushedAt', new Date());
  148. await o.save(null, { useMasterKey: true });
  149. } catch (e) { /* 记录失败不阻断推送 */ }
  150. }
  151. async function _cursorOf(userId, roomId) {
  152. try {
  153. var q = new Parse.Query(CURSOR_CLASS);
  154. q.equalTo('userId', userId);
  155. q.equalTo('roomId', roomId);
  156. return (await q.first({ useMasterKey: true })) || null;
  157. } catch (e) { return null; }
  158. }
  159. async function _saveCursor(userId, roomId, token) {
  160. try {
  161. var existing = await _cursorOf(userId, roomId);
  162. var obj = existing || new (Parse.Object.extend(CURSOR_CLASS))();
  163. obj.set('userId', userId);
  164. obj.set('roomId', roomId);
  165. obj.set('since', token);
  166. obj.set('updatedAt2', new Date());
  167. await obj.save(null, { useMasterKey: true });
  168. } catch (e) { /* 游标写失败下轮会重读,去重表挡住重复推送 */ }
  169. }
  170. /**
  171. * 找出「已经有游标、需要继续检查」的房间。
  172. *
  173. * 老账号可能加入过 800+ 个房间,逐个读 messages 会超时。
  174. * 但绝大多数是几天前就结束的历史会话 —— 它们的游标早已追平,
  175. * 不可能再冒出新的 idle 事件。
  176. *
  177. * 因此只保留**已经建过游标**的房间:首轮会给活跃房间建游标,
  178. * 之后每轮真正要读的通常只有「刚有活动的几个」。
  179. * 想精确到某个房间,调用方直接传 `roomIds`。
  180. */
  181. /**
  182. * 找出「需要检查」的房间。
  183. *
  184. * 🔴 判据:**游标是否落后于房间的最新事件**(2026-11-22 修正)。
  185. *
  186. * 早先我用「游标创建时间 >= 某个上线时刻」来剔除历史数据,那是错的:
  187. * 正常在用的房间(如 lj-test 那个)游标建得早,会被误判成历史而**永远不检查**,
  188. * 表现为「任务完成了但没推送」。
  189. *
  190. * 现在的做法:对每个有游标的房间拉 1 条最新事件比对 event_id:
  191. * · 不一致 → 落后了,需要检查(这轮可能有新的 idle)
  192. * · 一致 → 已追平,跳过
  193. * 每个房间只拉 1 条,成本很低。
  194. */
  195. async function _roomsBehindCursor(userId, token, rooms) {
  196. var known = {};
  197. try {
  198. var q = new Parse.Query(CURSOR_CLASS);
  199. var ref = new Parse.User();
  200. ref.id = userId;
  201. q.equalTo('userId', ref);
  202. q.limit(1000);
  203. var list = await q.find({ useMasterKey: true });
  204. for (var i = 0; i < list.length; i++) {
  205. known[list[i].get('roomId')] = list[i].get('since') || '';
  206. }
  207. } catch (e) { return []; }
  208. var out = [];
  209. for (var r = 0; r < rooms.length; r++) {
  210. var rid = rooms[r];
  211. var since = known[rid];
  212. if (since === undefined) continue; // 没游标 = 历史房间,不追踪
  213. if (!since) { out.push({ roomId: rid, since: '' }); continue; }
  214. // 探测该房间当前最新事件
  215. var probe = await _mxGet(token, '/_matrix/client/v3/rooms/' + encodeURIComponent(rid) +
  216. '/messages?dir=b&limit=1');
  217. if (!probe.ok || !probe.data || !probe.data.chunk || !probe.data.chunk.length) continue;
  218. var latestId = probe.data.chunk[0].event_id;
  219. // 落后才纳入;已追平则跳过(绝大多数历史房间走这条)
  220. if (latestId !== since) out.push({ roomId: rid, since: since });
  221. }
  222. return out;
  223. }
  224. /** 该用户是否已完成首轮游标初始化(把历史回合标为已读) */
  225. async function _initDone(userId) {
  226. try {
  227. var q = new Parse.Query(LOG_CLASS);
  228. q.equalTo('eventId', 'init:' + userId);
  229. q.limit(1);
  230. return (await q.find({ useMasterKey: true })).length > 0;
  231. } catch (e) { return false; }
  232. }
  233. async function _markInitDone(userId) {
  234. return _markPushed('init:' + userId, userId, '', '');
  235. }
  236. /**
  237. * 首轮:给「最近 7 天有事件」的房间建立游标起点。
  238. * 只记位置、不推历史 —— 否则上线瞬间会把几周的旧回合全推一遍。
  239. */
  240. async function _initCursors(userId, token, rooms, stats) {
  241. var done = 0;
  242. for (var i = 0; i < rooms.length; i++) {
  243. var res = await _mxGet(token, '/_matrix/client/v3/rooms/' + encodeURIComponent(rooms[i]) +
  244. '/messages?dir=b&limit=1');
  245. if (!res.ok || !res.data || !res.data.chunk || !res.data.chunk.length) continue;
  246. var latest = res.data.chunk[0];
  247. if (!latest || !latest.event_id) continue;
  248. var ts = latest.origin_server_ts || 0;
  249. if (Date.now() - ts > 7 * 24 * 3600 * 1000) continue; // 7 天前的房间不追踪
  250. // 已存在游标的房间保留原值(不能把进度重置回最新)
  251. var existing = await _cursorOf(userId, rooms[i]);
  252. if (!existing) await _saveCursor(userId, rooms[i], latest.event_id);
  253. done++;
  254. }
  255. stats.initRooms = done;
  256. }
  257. /** 调推送云函数(服务端批量) */
  258. async function _push(targets) {
  259. return _httpJson(FUNCTIONS_URL, {
  260. method: 'POST',
  261. headers: {
  262. 'Content-Type': 'application/json',
  263. 'X-Parse-Application-Id': 'ncloudmaster',
  264. 'X-Fmode-Push-Token': SERVER_TOKEN,
  265. },
  266. body: { id: PUSH_FN_ID, params: { targets: targets } },
  267. });
  268. }
  269. /**
  270. * 候选用户:来自 FmodeMatrixBinding(已接入 Matrix 的用户 + 长效 token)。
  271. * 同一用户多条绑定(每个容器一条)时只取一条。
  272. */
  273. async function _candidateUsers(limit) {
  274. var q = new Parse.Query('FmodeMatrixBinding');
  275. q.equalTo('status', 'active');
  276. if (params && params.userId) {
  277. var ref = new Parse.User();
  278. ref.id = String(params.userId);
  279. q.equalTo('userPointer', ref);
  280. } else {
  281. q.descending('updatedAt');
  282. }
  283. q.include('userPointer');
  284. q.limit(Math.max(1, Math.min(MAX_USERS, limit || MAX_USERS)) * 10);
  285. var all = await q.find({ useMasterKey: true });
  286. var seen = {};
  287. var out = [];
  288. for (var i = 0; i < all.length; i++) {
  289. if (out.length >= (limit || MAX_USERS)) break;
  290. var b = all[i];
  291. var u = b.get('userPointer');
  292. if (!u || !u.id || seen[u.id]) continue;
  293. seen[u.id] = true;
  294. out.push({ user: u, binding: b });
  295. }
  296. return out;
  297. }
  298. /**
  299. * 主流程:只处理「回合完成」事件。
  300. *
  301. * 每个房间:
  302. * 1. 读最近事件(增量:从上次游标往后);
  303. * 2. 找到最后一个 idle 事件 —— 判定为「这一轮完成」;
  304. * 3. 若该回合没推过 → 组织摘要 → 推送 → 记去重;
  305. * 4. 游标推进到最新。
  306. *
  307. * 关键:**一轮只推一次**,靠「idle 事件的 event_id」去重,
  308. * 与中间产生了多少条消息无关。
  309. */
  310. async function _run(dryRun, limit) {
  311. var stats = { users: 0, rooms: 0, turnsFound: 0, pushed: 0, skippedQuiet: 0, errors: [] };
  312. var candidates = await _candidateUsers(limit);
  313. var onlyRooms = params && Array.isArray(params.roomIds) && params.roomIds.length
  314. ? params.roomIds.map(String)
  315. : null;
  316. for (var ci = 0; ci < candidates.length; ci++) {
  317. var user = candidates[ci].user;
  318. var binding = candidates[ci].binding;
  319. var token = binding.get('accessToken');
  320. if (!token) { stats.errors.push(user.id + ': 无 Matrix token'); continue; }
  321. var alias = user.id; // 极光别名 = Parse Object ID
  322. stats.users++;
  323. var joined = await _mxGet(token, '/_matrix/client/v3/joined_rooms');
  324. if (!joined.ok || !joined.data || !joined.data.joined_rooms) {
  325. stats.errors.push(user.id + ': joined_rooms ' + (joined.status || joined.err));
  326. continue;
  327. }
  328. var rooms = joined.data.joined_rooms;
  329. if (onlyRooms) {
  330. rooms = rooms.filter(function (r) { return onlyRooms.indexOf(r) >= 0; });
  331. } else {
  332. /*
  333. * 🔴 只检查「游标还没有追到最新」的房间(2026-11-22 性能修正)。
  334. *
  335. * 实测:老账号加入过 841 个房间,逐房间读 messages 要 40+ 秒,
  336. * 而绝大多数是几天前就结束的历史会话 —— 它们的游标早就追平,
  337. * 里面不可能再冒出新的 idle 事件。
  338. *
  339. * 首轮会给每个房间建一次游标(一次性成本),之后每轮真正要读的
  340. * 通常只有「刚有活动的几个房间」。
  341. * 想精确到某个房间,调用方直接传 `roomIds` 即可。
  342. */
  343. var initDone = await _initDone(user.id);
  344. if (!initDone) {
  345. /*
  346. * 首轮(每个用户只做一次):给所有房间建「当前最新事件」游标。
  347. * 只记位置、不推历史 —— 否则上线瞬间会把几周的旧回合全推一遍。
  348. * 做完打标记,之后每轮只检查这些房间。
  349. */
  350. await _initCursors(user.id, token, rooms, stats);
  351. await _markInitDone(user.id);
  352. rooms = [];
  353. } else {
  354. rooms = await _roomsBehindCursor(user.id, token, rooms);
  355. }
  356. }
  357. stats.rooms += rooms.length;
  358. if (!rooms.length) { stats.errors.push(user.id + ': 无待检查房间'); continue; }
  359. for (var ri = 0; ri < rooms.length; ri++) {
  360. var roomId = onlyRooms ? rooms[ri] : rooms[ri].roomId;
  361. var curSince = onlyRooms ? null : (rooms[ri].since || null);
  362. var path = '/_matrix/client/v3/rooms/' + encodeURIComponent(roomId) +
  363. '/messages?dir=b&limit=' + PER_ROOM_LIMIT;
  364. var res = await _mxGet(token, path);
  365. if (!res.ok || !res.data || !res.data.chunk) {
  366. stats.errors.push(user.id + '/' + roomId.slice(0, 10) + ': messages ' + (res.status || res.err));
  367. continue;
  368. }
  369. // chunk 是倒序(最新在前)
  370. var chunk = res.data.chunk;
  371. var since = curSince;
  372. /*
  373. * 找到「最新的一条 idle 事件」,以及它所属这一轮的消息区间。
  374. * 首次见房间(无游标)只记位置不推,避免上线瞬间补推历史。
  375. */
  376. var idleAt = -1;
  377. for (var k = 0; k < chunk.length; k++) {
  378. if (_isTurnIdle(chunk[k])) { idleAt = k; break; }
  379. }
  380. if (!since) {
  381. // 首次:把游标定在最新事件上,不推历史
  382. if (chunk.length && chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id);
  383. continue;
  384. }
  385. if (idleAt < 0) continue; // 本轮没有「完成」事件,不推
  386. var idleEv = chunk[idleAt];
  387. var turnKey = 'turn:' + idleEv.event_id;
  388. stats.turnsFound++;
  389. if (await _alreadyPushed(turnKey)) {
  390. if (chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id);
  391. continue;
  392. }
  393. // 只取游标之后的事件,且到 idle 为止(即这一轮的内容)
  394. var turnEvents = [];
  395. for (var j = idleAt; j < chunk.length; j++) {
  396. if (chunk[j].event_id === since) break;
  397. turnEvents.push(chunk[j]);
  398. }
  399. // 倒序转正序,摘要取最后一条实质内容
  400. turnEvents.reverse();
  401. var summary = _summaryOfEvents(turnEvents);
  402. if (!summary) summary = '任务已完成,点击查看结果。';
  403. if (_inQuietHours()) {
  404. stats.skippedQuiet++;
  405. await _markPushed(turnKey, user.id, alias, '');
  406. if (chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id);
  407. continue;
  408. }
  409. var agentLocal = String(idleEv.sender || '').split(':')[0].replace(/^@/, '');
  410. var target = {
  411. alias: alias,
  412. alert: summary,
  413. title: '任务已完成',
  414. deepLink: 'fmode://chat/' + agentLocal + '/' + encodeURIComponent(roomId),
  415. businessKey: turnKey,
  416. };
  417. if (dryRun) {
  418. stats.pushed++;
  419. stats.errors.push('DRY ' + JSON.stringify(target).slice(0, 200));
  420. } else {
  421. var pr = await _push([target]);
  422. var sent = pr.ok && pr.data && pr.data.sent ? pr.data.sent : [];
  423. var row = sent[0] || {};
  424. if (row.msgId) {
  425. stats.pushed++;
  426. await _markPushed(turnKey, user.id, alias, row.msgId);
  427. if (chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id);
  428. } else {
  429. // 推送失败:**不推进游标**,下轮重试(去重表保证已推的不重推)
  430. stats.errors.push('push ' + user.id + ': ' + (row.error || (pr.status || 'unknown')));
  431. }
  432. }
  433. }
  434. }
  435. return stats;
  436. }
  437. async function handler(request, response) {
  438. try {
  439. var key = _serverKey();
  440. if (!key || key !== SERVER_TOKEN) return _fail(403, '禁止调用:需服务端凭据');
  441. var dryRun = !!(params && params.dryRun === true);
  442. var limit = params && params.limit ? Number(params.limit) : MAX_USERS;
  443. var stats = await _run(dryRun, limit);
  444. return _ok(stats);
  445. } catch (e) {
  446. return _fail(500, (e && e.message) || String(e));
  447. }
  448. }