// fmodeagent-push-watch —— 任务完成后把结果推给用户(v1.0.0 · 2026-11-22 重写) // // ============ 一句话 ============ // // **只在「这一轮任务全部完成」时推一条**,不推过程、不推中间消息。 // // ============ 触发源:容器主动发的回合完成事件 ============ // // 容器在每轮任务结束时(正文发完之后)往房间写一个事件: // // type: com.fmode.turn_status // content: { sessionKey: "", status: "running" | "idle" } // // `status: "idle"` 就是「这轮完了」——这是容器自己给的结论,服务端**不需要** // 去猜消息发到哪、也不需要定时轮询。 // // 原先的实现是「每 30–60 秒轮询所有用户房间、有新消息就推」,那是错的: // · 要平台配定时任务; // · 一轮任务会产生十几条工具调用消息 → 推十几条; // · 判断不了「任务完成」,只能按消息逐条推。 // 现在改为**按事件触发**,一次任务 = 一条推送。 // // ============ 调用方式 ============ // // 由「谁检测到 idle 就调一次」——调用方持服务端凭据: // // POST https://server.fmode.cn/api/functions // X-Parse-Application-Id: ncloudmaster // X-Fmode-Push-Token: // { "id": "<本函数 objectId>", params: { userId?, roomIds?: [...] } } // // · 不传参数 → 扫描所有绑定用户的房间,找「刚完成」的回合 // · 传 userId / roomIds → 只检查这些目标(推荐,范围明确) // // 安全:没有任何匿名放行分支。服务端凭据只在本文件与本函数内。 // // 版本 v1.0.0 · 2026-11-22 var MATRIX_HS = 'https://matrix.fmode.cn'; var MATRIX_DOMAIN = 'fmode.cn'; var PUSH_FN_ID = 'oCRJCCdiAx'; // fmodeagent-push(同目录) var FUNCTIONS_URL = 'https://server.fmode.cn/api/functions'; var SERVER_TOKEN = 'fmpush-srv-2026-11-c33a9e71'; var CURSOR_CLASS = 'FmodePushCursor'; // 每个房间已处理到哪个事件 var LOG_CLASS = 'FmodePushLog'; // 已推送过的回合(去重) var MAX_USERS = 50; var PER_ROOM_LIMIT = 30; // 单房间回看多少条事件 /** 游标有效性起点:早于此刻的游标视为历史遗留,不参与筛选 */ var CURSOR_EPOCH = 0; // 已废弃:改用「游标是否落后于最新事件」判定 /** 静默时段(服务器本地时区小时数):[quietStart, quietEnd) */ var QUIET_START = 23; var QUIET_END = 8; function _fail(code, mess) { response.status(code).json({ code: code, mess: mess }); } function _ok(data) { response.status(200).json(Object.assign({ code: 200 }, data)); } /** 服务端凭据:只认 X-Fmode-Push-Token(或 body 里的 cronKey),没有匿名分支 */ function _serverKey() { var h = (request && request.headers) || {}; if (h['x-fmode-push-token']) return h['x-fmode-push-token']; if (params && params.serverToken) return params.serverToken; if (params && params.cronKey) return params.cronKey; return null; } function _httpJson(url, opts) { return new Promise(function (resolve) { try { if (typeof fetch !== 'function') { resolve({ ok: false, err: 'no fetch' }); return; } var ctrl = typeof AbortController === 'function' ? new AbortController() : null; var t = ctrl ? setTimeout(function () { try { ctrl.abort(); } catch (e) {} }, 12000) : null; var init = { method: (opts && opts.method) || 'GET', headers: (opts && opts.headers) || {} }; if (ctrl) init.signal = ctrl.signal; if (opts && opts.body !== undefined) init.body = JSON.stringify(opts.body); fetch(url, init).then(function (res) { return res.text().then(function (txt) { if (t) clearTimeout(t); var data = null; try { data = JSON.parse(txt); } catch (e) { data = { raw: String(txt).slice(0, 300) }; } resolve({ ok: res.status >= 200 && res.status < 300, status: res.status, data: data }); }); }).catch(function (e) { if (t) clearTimeout(t); resolve({ ok: false, err: String(e) }); }); } catch (e) { resolve({ ok: false, err: String(e) }); } }); } function _mxGet(token, path) { var url = MATRIX_HS + path; url += (url.indexOf('?') >= 0 ? '&' : '?') + 'access_token=' + encodeURIComponent(token); return _httpJson(url, { method: 'GET' }); } function _inQuietHours() { var h = new Date().getHours(); return QUIET_START > QUIET_END ? (h >= QUIET_START || h < QUIET_END) : (h >= QUIET_START && h < QUIET_END); } function _truncate(s, n) { s = String(s || '').replace(/\s+/g, ' ').trim(); return s.length <= n ? s : s.slice(0, n - 1) + '…'; } /** * 是不是「回合完成」事件。 * * 容器约定:`com.fmode.turn_status` + `status: "idle"`。 * 同时兼容 `m.room.message` 里带 `fmode.turn_status` 的兜底写法。 */ function _isTurnIdle(ev) { if (!ev) return false; var c = ev.content || {}; var payload = null; if (ev.type === 'com.fmode.turn_status') payload = c; else if (ev.type === 'm.room.message' && c['fmode.turn_status']) payload = c['fmode.turn_status']; if (!payload) return false; return String(payload.status || '') === 'idle'; } /** 从一轮消息里提取「这一轮说了什么」,用于通知正文 */ function _summaryOfEvents(events) { var texts = []; for (var i = 0; i < events.length; i++) { var ev = events[i]; if (!ev || ev.type !== 'm.room.message') continue; var c = ev.content || {}; if (c['fmode.turn_status']) continue; // 状态型,不算正文 var body = typeof c.body === 'string' ? c.body : ''; if (!body) continue; var t = body.trim(); // 工具调用碎片不进摘要 if (t.indexOf('💻') === 0 || t.indexOf('$ ') === 0) continue; if (t.indexOf('```') === 0) continue; texts.push(t); } if (!texts.length) return ''; // 取最后一段实质内容作为摘要(容器通常是「结论在最后」) return _truncate(texts[texts.length - 1], 120); } async function _alreadyPushed(key) { try { var q = new Parse.Query(LOG_CLASS); q.equalTo('eventId', key); q.limit(1); var r = await q.find({ useMasterKey: true }); return r.length > 0; } catch (e) { return false; } } async function _markPushed(key, userId, alias, msgId) { try { var O = Parse.Object.extend(LOG_CLASS); var o = new O(); o.set('eventId', key); o.set('userId', userId); o.set('alias', alias); o.set('msgId', msgId || ''); o.set('pushedAt', new Date()); await o.save(null, { useMasterKey: true }); } catch (e) { /* 记录失败不阻断推送 */ } } async function _cursorOf(userId, roomId) { try { var q = new Parse.Query(CURSOR_CLASS); q.equalTo('userId', userId); q.equalTo('roomId', roomId); return (await q.first({ useMasterKey: true })) || null; } catch (e) { return null; } } async function _saveCursor(userId, roomId, token) { try { var existing = await _cursorOf(userId, roomId); var obj = existing || new (Parse.Object.extend(CURSOR_CLASS))(); obj.set('userId', userId); obj.set('roomId', roomId); obj.set('since', token); obj.set('updatedAt2', new Date()); await obj.save(null, { useMasterKey: true }); } catch (e) { /* 游标写失败下轮会重读,去重表挡住重复推送 */ } } /** * 找出「已经有游标、需要继续检查」的房间。 * * 老账号可能加入过 800+ 个房间,逐个读 messages 会超时。 * 但绝大多数是几天前就结束的历史会话 —— 它们的游标早已追平, * 不可能再冒出新的 idle 事件。 * * 因此只保留**已经建过游标**的房间:首轮会给活跃房间建游标, * 之后每轮真正要读的通常只有「刚有活动的几个」。 * 想精确到某个房间,调用方直接传 `roomIds`。 */ /** * 找出「需要检查」的房间。 * * 🔴 判据:**游标是否落后于房间的最新事件**(2026-11-22 修正)。 * * 早先我用「游标创建时间 >= 某个上线时刻」来剔除历史数据,那是错的: * 正常在用的房间(如 lj-test 那个)游标建得早,会被误判成历史而**永远不检查**, * 表现为「任务完成了但没推送」。 * * 现在的做法:对每个有游标的房间拉 1 条最新事件比对 event_id: * · 不一致 → 落后了,需要检查(这轮可能有新的 idle) * · 一致 → 已追平,跳过 * 每个房间只拉 1 条,成本很低。 */ async function _roomsBehindCursor(userId, token, rooms) { var known = {}; try { var q = new Parse.Query(CURSOR_CLASS); var ref = new Parse.User(); ref.id = userId; q.equalTo('userId', ref); q.limit(1000); var list = await q.find({ useMasterKey: true }); for (var i = 0; i < list.length; i++) { known[list[i].get('roomId')] = list[i].get('since') || ''; } } catch (e) { return []; } var out = []; for (var r = 0; r < rooms.length; r++) { var rid = rooms[r]; var since = known[rid]; if (since === undefined) continue; // 没游标 = 历史房间,不追踪 if (!since) { out.push({ roomId: rid, since: '' }); continue; } // 探测该房间当前最新事件 var probe = await _mxGet(token, '/_matrix/client/v3/rooms/' + encodeURIComponent(rid) + '/messages?dir=b&limit=1'); if (!probe.ok || !probe.data || !probe.data.chunk || !probe.data.chunk.length) continue; var latestId = probe.data.chunk[0].event_id; // 落后才纳入;已追平则跳过(绝大多数历史房间走这条) if (latestId !== since) out.push({ roomId: rid, since: since }); } return out; } /** 该用户是否已完成首轮游标初始化(把历史回合标为已读) */ async function _initDone(userId) { try { var q = new Parse.Query(LOG_CLASS); q.equalTo('eventId', 'init:' + userId); q.limit(1); return (await q.find({ useMasterKey: true })).length > 0; } catch (e) { return false; } } async function _markInitDone(userId) { return _markPushed('init:' + userId, userId, '', ''); } /** * 首轮:给「最近 7 天有事件」的房间建立游标起点。 * 只记位置、不推历史 —— 否则上线瞬间会把几周的旧回合全推一遍。 */ async function _initCursors(userId, token, rooms, stats) { var done = 0; for (var i = 0; i < rooms.length; i++) { var res = await _mxGet(token, '/_matrix/client/v3/rooms/' + encodeURIComponent(rooms[i]) + '/messages?dir=b&limit=1'); if (!res.ok || !res.data || !res.data.chunk || !res.data.chunk.length) continue; var latest = res.data.chunk[0]; if (!latest || !latest.event_id) continue; var ts = latest.origin_server_ts || 0; if (Date.now() - ts > 7 * 24 * 3600 * 1000) continue; // 7 天前的房间不追踪 // 已存在游标的房间保留原值(不能把进度重置回最新) var existing = await _cursorOf(userId, rooms[i]); if (!existing) await _saveCursor(userId, rooms[i], latest.event_id); done++; } stats.initRooms = done; } /** 调推送云函数(服务端批量) */ async function _push(targets) { return _httpJson(FUNCTIONS_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', 'X-Parse-Application-Id': 'ncloudmaster', 'X-Fmode-Push-Token': SERVER_TOKEN, }, body: { id: PUSH_FN_ID, params: { targets: targets } }, }); } /** * 候选用户:来自 FmodeMatrixBinding(已接入 Matrix 的用户 + 长效 token)。 * 同一用户多条绑定(每个容器一条)时只取一条。 */ async function _candidateUsers(limit) { var q = new Parse.Query('FmodeMatrixBinding'); q.equalTo('status', 'active'); if (params && params.userId) { var ref = new Parse.User(); ref.id = String(params.userId); q.equalTo('userPointer', ref); } else { q.descending('updatedAt'); } q.include('userPointer'); q.limit(Math.max(1, Math.min(MAX_USERS, limit || MAX_USERS)) * 10); var all = await q.find({ useMasterKey: true }); var seen = {}; var out = []; for (var i = 0; i < all.length; i++) { if (out.length >= (limit || MAX_USERS)) break; var b = all[i]; var u = b.get('userPointer'); if (!u || !u.id || seen[u.id]) continue; seen[u.id] = true; out.push({ user: u, binding: b }); } return out; } /** * 主流程:只处理「回合完成」事件。 * * 每个房间: * 1. 读最近事件(增量:从上次游标往后); * 2. 找到最后一个 idle 事件 —— 判定为「这一轮完成」; * 3. 若该回合没推过 → 组织摘要 → 推送 → 记去重; * 4. 游标推进到最新。 * * 关键:**一轮只推一次**,靠「idle 事件的 event_id」去重, * 与中间产生了多少条消息无关。 */ async function _run(dryRun, limit) { var stats = { users: 0, rooms: 0, turnsFound: 0, pushed: 0, skippedQuiet: 0, errors: [] }; var candidates = await _candidateUsers(limit); var onlyRooms = params && Array.isArray(params.roomIds) && params.roomIds.length ? params.roomIds.map(String) : null; for (var ci = 0; ci < candidates.length; ci++) { var user = candidates[ci].user; var binding = candidates[ci].binding; var token = binding.get('accessToken'); if (!token) { stats.errors.push(user.id + ': 无 Matrix token'); continue; } var alias = user.id; // 极光别名 = Parse Object ID stats.users++; var joined = await _mxGet(token, '/_matrix/client/v3/joined_rooms'); if (!joined.ok || !joined.data || !joined.data.joined_rooms) { stats.errors.push(user.id + ': joined_rooms ' + (joined.status || joined.err)); continue; } var rooms = joined.data.joined_rooms; if (onlyRooms) { rooms = rooms.filter(function (r) { return onlyRooms.indexOf(r) >= 0; }); } else { /* * 🔴 只检查「游标还没有追到最新」的房间(2026-11-22 性能修正)。 * * 实测:老账号加入过 841 个房间,逐房间读 messages 要 40+ 秒, * 而绝大多数是几天前就结束的历史会话 —— 它们的游标早就追平, * 里面不可能再冒出新的 idle 事件。 * * 首轮会给每个房间建一次游标(一次性成本),之后每轮真正要读的 * 通常只有「刚有活动的几个房间」。 * 想精确到某个房间,调用方直接传 `roomIds` 即可。 */ var initDone = await _initDone(user.id); if (!initDone) { /* * 首轮(每个用户只做一次):给所有房间建「当前最新事件」游标。 * 只记位置、不推历史 —— 否则上线瞬间会把几周的旧回合全推一遍。 * 做完打标记,之后每轮只检查这些房间。 */ await _initCursors(user.id, token, rooms, stats); await _markInitDone(user.id); rooms = []; } else { rooms = await _roomsBehindCursor(user.id, token, rooms); } } stats.rooms += rooms.length; if (!rooms.length) { stats.errors.push(user.id + ': 无待检查房间'); continue; } for (var ri = 0; ri < rooms.length; ri++) { var roomId = onlyRooms ? rooms[ri] : rooms[ri].roomId; var curSince = onlyRooms ? null : (rooms[ri].since || null); var path = '/_matrix/client/v3/rooms/' + encodeURIComponent(roomId) + '/messages?dir=b&limit=' + PER_ROOM_LIMIT; var res = await _mxGet(token, path); if (!res.ok || !res.data || !res.data.chunk) { stats.errors.push(user.id + '/' + roomId.slice(0, 10) + ': messages ' + (res.status || res.err)); continue; } // chunk 是倒序(最新在前) var chunk = res.data.chunk; var since = curSince; /* * 找到「最新的一条 idle 事件」,以及它所属这一轮的消息区间。 * 首次见房间(无游标)只记位置不推,避免上线瞬间补推历史。 */ var idleAt = -1; for (var k = 0; k < chunk.length; k++) { if (_isTurnIdle(chunk[k])) { idleAt = k; break; } } if (!since) { // 首次:把游标定在最新事件上,不推历史 if (chunk.length && chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id); continue; } if (idleAt < 0) continue; // 本轮没有「完成」事件,不推 var idleEv = chunk[idleAt]; var turnKey = 'turn:' + idleEv.event_id; stats.turnsFound++; if (await _alreadyPushed(turnKey)) { if (chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id); continue; } // 只取游标之后的事件,且到 idle 为止(即这一轮的内容) var turnEvents = []; for (var j = idleAt; j < chunk.length; j++) { if (chunk[j].event_id === since) break; turnEvents.push(chunk[j]); } // 倒序转正序,摘要取最后一条实质内容 turnEvents.reverse(); var summary = _summaryOfEvents(turnEvents); if (!summary) summary = '任务已完成,点击查看结果。'; if (_inQuietHours()) { stats.skippedQuiet++; await _markPushed(turnKey, user.id, alias, ''); if (chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id); continue; } var agentLocal = String(idleEv.sender || '').split(':')[0].replace(/^@/, ''); var target = { alias: alias, alert: summary, title: '任务已完成', deepLink: 'fmode://chat/' + agentLocal + '/' + encodeURIComponent(roomId), businessKey: turnKey, }; if (dryRun) { stats.pushed++; stats.errors.push('DRY ' + JSON.stringify(target).slice(0, 200)); } else { var pr = await _push([target]); var sent = pr.ok && pr.data && pr.data.sent ? pr.data.sent : []; var row = sent[0] || {}; if (row.msgId) { stats.pushed++; await _markPushed(turnKey, user.id, alias, row.msgId); if (chunk[0].event_id) await _saveCursor(user.id, roomId, chunk[0].event_id); } else { // 推送失败:**不推进游标**,下轮重试(去重表保证已推的不重推) stats.errors.push('push ' + user.id + ': ' + (row.error || (pr.status || 'unknown'))); } } } } return stats; } async function handler(request, response) { try { var key = _serverKey(); if (!key || key !== SERVER_TOKEN) return _fail(403, '禁止调用:需服务端凭据'); var dryRun = !!(params && params.dryRun === true); var limit = params && params.limit ? Number(params.limit) : MAX_USERS; var stats = await _run(dryRun, limit); return _ok(stats); } catch (e) { return _fail(500, (e && e.message) || String(e)); } }