From 4151599e8166c000fa67d6795ca44d485ef20f22 Mon Sep 17 00:00:00 2001 From: Teknium <127238744+teknium1@users.noreply.github.com> Date: Mon, 17 Aug 2026 14:43:33 -0700 Subject: [PATCH] =?UTF-8?q?fix(desktop):=20cross-machine=20bot=20DMs=20?= =?UTF-8?q?=E2=80=94=20canonical=20chat,=20sender=20attribution,=20reply?= =?UTF-8?q?=20relay?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Follow-up to #88664. The remote @mention delivery path had three gaps that made cross-machine DMs half-work: 1. No reply relay: deliverRemoteRosterMentions submitted the prompt and toasted, but never polled — the handoff note promised a relay that never came. Now a bounded poll (same shape as a group member turn: new assistant message after the baseline, 180s cap) relays the recipient's reply as a notification, or says it's still pending. 2. No sender attribution: the raw user text was submitted, so the recipient's messaging protocol never recognized an agent-to-agent message. Deliveries now carry the standard "Message from 🤖 (@handle):" prefix. 3. Duplicate Bot Chats: every mention minted a fresh "Bot Chat" session. ensureRemoteCanonicalChat now resolves the recipient's pinned canonical chat from its profile ui_meta, falls back to resume-by-title, and only creates when neither exists — mirroring ensureGroupChatSession. Tests: remote-dm-delivery.test.mjs (pin-resume without create, attribution prefix + reply relay via vm-run behavior tests, source contract for the bounded poll). Plugin suite 187/187. --- .../desktop/src/plugins/hermes-bots/plugin.js | 164 +++++++++++++++--- .../tests/remote-dm-delivery.test.mjs | 134 ++++++++++++++ 2 files changed, 278 insertions(+), 20 deletions(-) create mode 100644 apps/desktop/src/plugins/hermes-bots/tests/remote-dm-delivery.test.mjs diff --git a/apps/desktop/src/plugins/hermes-bots/plugin.js b/apps/desktop/src/plugins/hermes-bots/plugin.js index 7d65060de0..81eeaaf8fc 100644 --- a/apps/desktop/src/plugins/hermes-bots/plugin.js +++ b/apps/desktop/src/plugins/hermes-bots/plugin.js @@ -2485,13 +2485,109 @@ function resolveRosterMentions(text, roster, active = {}) { return mentioned } -async function deliverRemoteRosterMentions(bots, userText) { +const REMOTE_DM_TIMEOUT_MS = 180000 +const REMOTE_DM_POLL_MS = 2000 + +/** The remote bot's canonical Bot Chat: pinned stored-id from its profile's + * ui_meta first, then resume-by-title, then create. Mirrors + * ensureGroupChatSession so DMs land in the ONE forever-chat instead of + * minting a fresh "Bot Chat" per mention. */ +async function ensureRemoteCanonicalChat(route, profile) { + let pinned = null + + try { + const listed = await host.requestProfile(route, 'profiles.list', {}) + const owner = listed?.profiles?.find(p => p.name === profile) + pinned = owner?.ui_meta?.['hermes-bots']?.chat || null + } catch { + /* older remote gateway — title lookup below still works */ + } + + for (const target of [pinned, 'Bot Chat']) { + if (!target) { + continue + } + + try { + const res = await host.requestProfile(route, 'session.resume', { + session_id: target, + profile, + omit_messages: true + }) + + if (res?.session_id) { + return { runtime: res.session_id, stored: res.session_key || pinned } + } + } catch { + /* fall through */ + } + } + + const created = await host.requestProfile(route, 'session.create', { + profile, + title: 'Bot Chat', + ...($hideBotChats.get() ? { hidden: true } : {}) + }) + + return { runtime: created?.session_id || null, stored: created?.stored_session_id || null } +} + +/** Bounded reply poll on the recipient's session — same shape as a group + * member turn: wait for a NEW assistant message after `before`, or time out. */ +async function pollRemoteDmReply(route, profile, sessionRef, before) { + const deadline = Date.now() + REMOTE_DM_TIMEOUT_MS + + while (Date.now() < deadline) { + await new Promise(resolve => setTimeout(resolve, REMOTE_DM_POLL_MS)) + + let state = null + + try { + state = await host.requestProfile(route, 'session.resume', { session_id: sessionRef, profile }) + } catch { + continue + } + + const messages = Array.isArray(state?.messages) ? state.messages : [] + const done = !state?.inflight && !state?.running + + if (messages.length > before && done) { + for (let i = messages.length - 1; i >= 0; i--) { + const msg = messages[i] + + if (msg?.role === 'assistant') { + const text = typeof msg.content === 'string' + ? msg.content + : Array.isArray(msg.content) + ? msg.content.map(p => (typeof p === 'string' ? p : p?.text || '')).join('') + : msg?.text || '' + + return String(text).trim() || null + } + } + + return null + } + } + + return null +} + +/** Deliver a user mention to bots on OTHER connections: into each bot's + * canonical Bot Chat, with the standard sender-attribution prefix (so the + * recipient's messaging protocol recognizes an agent-to-agent message), then + * relay the reply back as a notification. Sequential and fire-and-forget + * from the composer's perspective. */ +async function deliverRemoteRosterMentions(bots, userText, sender) { const text = String(userText || '').trim() if (!text || typeof host.requestProfile !== 'function') { return } + const senderName = String(sender?.name || 'the user').trim() + const senderHandle = String(sender?.handle || senderName).trim() + for (const bot of bots) { const connectionId = String(bot?.connectionId || '').trim() const profile = String(bot?.name || '').trim() || 'default' @@ -2500,30 +2596,55 @@ async function deliverRemoteRosterMentions(bots, userText) { continue } - try { - const created = await host.requestProfile( - { connectionId, profile, mode: 'remote', targetProfile: profile }, - 'session.create', - { profile, title: 'Bot Chat', hidden: true } - ) - const sessionId = created?.session_id + const route = { connectionId, mode: 'remote', profile, targetProfile: profile } + const label = bot.connectionLabel || connectionId - if (!sessionId) { + try { + const { runtime, stored } = await ensureRemoteCanonicalChat(route, profile) + + if (!runtime) { throw new Error('No remote session') } - await host.requestProfile( - { connectionId, profile, mode: 'remote', targetProfile: profile }, - 'prompt.submit', - { session_id: sessionId, text } - ) + // Baseline before our submit, so the poll can spot the NEW reply. + let before = 0 + + try { + const pre = await host.requestProfile(route, 'session.resume', { session_id: stored || runtime, profile }) + before = Array.isArray(pre?.messages) ? pre.messages.length : pre?.message_count || 0 + } catch { + /* lazy session — zero messages */ + } + + // The delivery prefix is the recipient's cue that an agent (not its + // human) is talking — same contract as the local CLI handoff. + await host.requestProfile(route, 'prompt.submit', { + session_id: runtime, + text: `Message from \u{1F916} ${senderName} (@${senderHandle}): ${text}` + }) host.notify?.({ kind: 'info', title: displayName(bot), - message: `Messaged @${botHandle(profile, bot)} on ${bot.connectionLabel || connectionId} from this chat.` + message: `Messaged @${botHandle(profile, bot)} on ${label} — will relay the reply here.` }) + + const reply = await pollRemoteDmReply(route, profile, stored || runtime, before) + + if (reply) { + host.notify?.({ + kind: 'info', + title: `\u{1F916} ${displayName(bot)} (${label})`, + message: reply.slice(0, 500) + }) + } else { + host.notify?.({ + kind: 'info', + title: displayName(bot), + message: `No reply from @${botHandle(profile, bot)} yet — check its Bot Chat on ${label}.` + }) + } } catch (error) { - host.notifyError?.(error, `Could not reach ${bot.connectionLabel || profile}`) + host.notifyError?.(error, `Could not reach ${label}`) } } } @@ -7862,12 +7983,15 @@ export default { const localMentions = mentionedBots.filter(bot => !bot.remoteSource) const remoteMentions = mentionedBots.filter(bot => bot.remoteSource) - if (remoteMentions.length && typeof host.requestProfile === 'function') { - void deliverRemoteRosterMentions(remoteMentions, text) - } - const activeMeta = $botMeta.get()[live.name] const senderName = displayName({ name: live.name, title: activeMeta?.title }, activeMeta) + + if (remoteMentions.length && typeof host.requestProfile === 'function') { + void deliverRemoteRosterMentions(remoteMentions, text, { + name: senderName, + handle: botHandle(live.name) + }) + } let note = '' if (localMentions.length) { diff --git a/apps/desktop/src/plugins/hermes-bots/tests/remote-dm-delivery.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/remote-dm-delivery.test.mjs new file mode 100644 index 0000000000..d864d637ce --- /dev/null +++ b/apps/desktop/src/plugins/hermes-bots/tests/remote-dm-delivery.test.mjs @@ -0,0 +1,134 @@ +import assert from 'node:assert/strict' +import { readFileSync } from 'node:fs' +import test from 'node:test' +import vm from 'node:vm' + +// Cross-machine bot DMs: a remote @mention must land in the recipient's +// CANONICAL Bot Chat (pinned id → title → create, never a fresh session per +// mention), carry the "Message from 🤖 (@handle):" attribution +// prefix so the recipient's messaging protocol recognizes an agent-to-agent +// message, and poll for the reply so it can be relayed back. + +const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8') + +function runtime(hostOverrides = {}) { + const context = { + console, + setTimeout: fn => { + fn() + return 0 + }, + clearTimeout: () => undefined, + Date, + URL, + atom: initial => { + let value = initial + return { get: () => value, set: next => (value = next), listen: () => () => undefined } + }, + host: { + request: async () => ({}), + requestProfile: async () => ({}), + notify: () => undefined, + notifyError: () => undefined, + state: { + profile: { get: () => 'default', listen: () => undefined }, + connectionId: { get: () => 'local', listen: () => undefined }, + gateway: { listen: () => undefined } + }, + ...hostOverrides + }, + document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } } + } + const code = pluginSource + .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '') + .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '') + .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '') + .replace(/^import .* from 'react'\r?\n/m, '') + .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '') + .replace('export default {', 'globalThis.plugin = {') + .concat('\nglobalThis.__dm = { deliverRemoteRosterMentions, ensureRemoteCanonicalChat };\n') + vm.runInNewContext(code, context, { filename: 'plugin.js' }) + return context +} + +test('remote DM resumes the pinned canonical Bot Chat instead of creating a new session', async () => { + const calls = [] + const ctx = runtime({ + requestProfile: async (route, method, params) => { + calls.push([method, params]) + + if (method === 'profiles.list') { + return { profiles: [{ name: 'dixie', ui_meta: { 'hermes-bots': { chat: 'stored-42' } } }] } + } + + if (method === 'session.resume' && params.session_id === 'stored-42') { + return { session_id: 'runtime-9', session_key: 'stored-42', messages: [] } + } + + if (method === 'session.resume') { + return { session_id: 'runtime-9', messages: [{ role: 'assistant', content: 'done' }], inflight: false, running: false } + } + + return {} + } + }) + + const { runtime: rt, stored } = await ctx.__dm.ensureRemoteCanonicalChat( + { connectionId: 'mac-mini', mode: 'remote', profile: 'dixie', targetProfile: 'dixie' }, + 'dixie' + ) + + assert.equal(rt, 'runtime-9') + assert.equal(stored, 'stored-42') + assert.ok(!calls.some(([method]) => method === 'session.create'), 'must not mint a fresh session when the pin resumes') +}) + +test('remote DM carries sender attribution and relays the reply', async () => { + const submits = [] + const notices = [] + const ctx = runtime({ + requestProfile: async (route, method, params) => { + if (method === 'profiles.list') { + return { profiles: [] } + } + + if (method === 'session.resume' && params.session_id === 'Bot Chat' && params.omit_messages) { + return { session_id: 'runtime-1', session_key: 'stored-1' } + } + + if (method === 'prompt.submit') { + submits.push(params.text) + return {} + } + + if (method === 'session.resume') { + // First (baseline) read: empty. After submit: reply present. + return submits.length + ? { messages: [{ role: 'user', content: 'x' }, { role: 'assistant', content: 'disk is 40% full' }], inflight: false, running: false } + : { messages: [] } + } + + return {} + }, + notify: notice => notices.push(notice) + }) + + await ctx.__dm.deliverRemoteRosterMentions( + [{ name: 'dixie', connectionId: 'mac-mini', connectionLabel: 'Mac Mini', remoteSource: true }], + 'what is the disk space?', + { name: 'Hermes', handle: 'hermes' } + ) + + assert.equal(submits.length, 1) + assert.match(submits[0], /^Message from 🤖 Hermes \(@hermes\): what is the disk space\?$/u) + assert.ok( + notices.some(notice => /disk is 40% full/.test(notice?.message || '')), + 'the recipient reply must be relayed back as a notification' + ) +}) + +test('source contract: DM poll shares the group-turn shape (bounded, new-assistant-message)', () => { + assert.match(pluginSource, /const REMOTE_DM_TIMEOUT_MS = /) + assert.match(pluginSource, /pollRemoteDmReply/) + assert.match(pluginSource, /Message from \\u\{1F916\} \$\{senderName\} \(@\$\{senderHandle\}\)/) +})