@oar-sh/oar 0.9.3 → 0.9.4

package/server/public/app/relay-prompt-sanitizer.mjs

@@ -1,3 +1,5 @@
+import { stripRemotePromptHeader } from './remote-relay-shared.mjs';
+
 const RELAY_TOOL_GUIDANCE = [
   '# Relay Tool Guidance',
   'For any user-facing question or clarification, use the ask_user tool so the web relay can render question cards and buttons. Never ask questions in plain assistant text.',
@@ -118,12 +120,36 @@ const STEER_NOTE_PATTERN = /^\s*\[Sent while you were still working on my previo
 // it is matched on its own, and only where it guards a "/".
 const SLASH_COMMAND_GUARD_PATTERN = /^\u200B(?=\s*\/)/;
 
-function stripLeadingRelayNotes(text) {
-  const stripped = String(text || '').replace(STEER_NOTE_PATTERN, '').replace(SLASH_COMMAND_GUARD_PATTERN, '');
+// The hint the relay adds to a turn whose user message mentions a remote relay
+// (docs/plans/2026-09-27-remote-relays.md §5.5). stripAttachmentPromptArtifacts
+// already drops every <system_reminder>; this narrower pattern is for text that
+// did not come through that path (a stored bubble the server already sanitised).
+const REMOTE_RELAY_MENTION_HINT_PATTERN = /<system_reminder>\s*The user mentioned the remote OAR relay[\s\S]*?<\/system_reminder>\s*/gi;
+
+function hasRemoteOrigin(origin) {
+  return !!origin && typeof origin === 'object';
+}
+
+function stripLeadingRelayNotes(text, { origin = null } = {}) {
+  const remote = hasRemoteOrigin(origin);
+  let stripped = String(text || '');
+  // A prompt another relay's agent sent starts with a header line naming it;
+  // the bubble's provenance badge carries the same facts, so it is hidden —
+  // but only when the message really carries `origin`, never on a lookalike a
+  // human typed. A steer note may sit in front of it.
+  if (remote) stripped = stripRemotePromptHeader(stripped.trimStart());
+  stripped = stripped.replace(STEER_NOTE_PATTERN, '');
+  if (remote) stripped = stripRemotePromptHeader(stripped.trimStart());
+  stripped = stripped.replace(SLASH_COMMAND_GUARD_PATTERN, '');
   return stripped.trim() ? stripped.trim() : String(text || '').trim();
 }
 
-export function stripRelayPromptContext(text, relayMode = '') {
+/**
+ * `options.origin`: the message's remote-relay provenance, when it has one.
+ * Only then is the remote prompt header line stripped.
+ */
+export function stripRelayPromptContext(text, relayMode = '', options = {}) {
+  const origin = options && typeof options === 'object' ? options.origin : null;
   const value = stripAttachmentPromptArtifacts(text)
     .replace(MEDIA_EMBED_BLOCK_PATTERN, '')
     .trim();
@@ -131,7 +157,24 @@ export function stripRelayPromptContext(text, relayMode = '') {
   const patterns = buildPromptPrefixPatterns(relayMode);
   for (const pattern of patterns) {
     const stripped = value.replace(pattern, '').trim();
-    if (stripped && stripped !== value) return stripLeadingRelayNotes(stripped);
+    if (stripped && stripped !== value) return stripLeadingRelayNotes(stripped, { origin });
+  }
+  return stripLeadingRelayNotes(value, { origin });
+}
+
+/**
+ * For a user bubble's text as it is about to render (already sanitised by the
+ * relay): drops a stray remote-relay mention hint, and the remote prompt header
+ * when the message carries `origin`. Text without either is returned untouched.
+ */
+export function stripRemoteRelayDisplayArtifacts(text, { origin = null } = {}) {
+  const value = String(text ?? '');
+  let next = value.replace(REMOTE_RELAY_MENTION_HINT_PATTERN, '');
+  if (hasRemoteOrigin(origin)) {
+    const leading = next.trimStart();
+    const withoutHeader = stripRemotePromptHeader(leading);
+    if (withoutHeader !== leading) next = withoutHeader;
   }
-  return stripLeadingRelayNotes(value);
+  if (next === value) return value;
+  return next.trim() ? next.trim() : value.trim();
 }

package/server/public/app/remote-relay-origin-view.mjs

@@ -0,0 +1,76 @@
+// Provenance of work another relay's agent started here: the badge on a user
+// bubble ("↗ from win-test · “report builder” · claude-sonnet-5", linking back
+// to the source session) and the "↗ win-test" marker on the sidebar row of a
+// conversation such an agent created. Both read the `origin` the relay stores
+// with the message or conversation (docs/plans/2026-09-27-remote-relays.md §4).
+
+import { remoteConversationUrl } from './remote-relay-shared.mjs';
+
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function oneLine(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+/** The display fields of an `origin`, or null when it names no relay. */
+export function normalizeRemoteOrigin(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const relayName = oneLine(raw.relayName);
+  const relayId = oneLine(raw.relayId);
+  if (!relayName && !relayId) return null;
+  const relayUrl = oneLine(raw.relayUrl);
+  return {
+    relayName: relayName || relayId,
+    relayUrl: /^https?:\/\//i.test(relayUrl) ? relayUrl : '',
+    conversationId: oneLine(raw.conversationId),
+    conversationTitle: oneLine(raw.conversationTitle),
+    model: oneLine(raw.model),
+  };
+}
+
+export function remoteOriginBadgeText(origin) {
+  const normalized = normalizeRemoteOrigin(origin);
+  if (!normalized) return '';
+  const parts = [`↗ from ${normalized.relayName}`];
+  if (normalized.conversationTitle) parts.push(`“${normalized.conversationTitle}”`);
+  if (normalized.model) parts.push(normalized.model);
+  return parts.join(' · ');
+}
+
+/** `<relayUrl>/?conv=<conversationId>`, or '' when the origin has no URL. */
+export function remoteOriginLink(origin) {
+  const normalized = normalizeRemoteOrigin(origin);
+  if (!normalized?.relayUrl) return '';
+  return remoteConversationUrl(normalized.relayUrl, normalized.conversationId);
+}
+
+/**
+ * The badge row that sits above a user bubble's text. `linkable: false` (the
+ * shared read-only view) renders it without the link to the other relay.
+ */
+export function renderRemoteOriginBadgeHtml(origin, { linkable = true } = {}) {
+  const normalized = normalizeRemoteOrigin(origin);
+  if (!normalized) return '';
+  const label = escapeHtml(remoteOriginBadgeText(normalized));
+  const href = linkable ? remoteOriginLink(normalized) : '';
+  const name = escapeHtml(normalized.relayName);
+  if (href) {
+    return `<div class="msg-origin"><a class="msg-origin-badge" href="${escapeHtml(href)}" target="_blank" rel="noopener" title="Sent by an agent on relay ${name}. Opens its session there.">${label}</a></div>`;
+  }
+  return `<div class="msg-origin"><span class="msg-origin-badge" title="Sent by an agent on relay ${name}.">${label}</span></div>`;
+}
+
+/** The sidebar marker for a conversation another relay's agent created. */
+export function renderConversationOriginMarkerHtml(conversation) {
+  const normalized = normalizeRemoteOrigin(conversation?.origin);
+  if (!normalized) return '';
+  const name = escapeHtml(normalized.relayName);
+  return `<span class="conv-origin-marker" title="Started by an agent on relay ${name}">↗ ${name}</span>`;
+}

package/server/public/app/remote-relay-shared.mjs

@@ -0,0 +1,85 @@
+// Browser mirror of the pieces of shared/remote-relay-contract.mjs and
+// shared/remote-relay-mentions.mjs the web UI needs. The browser cannot import
+// shared/ (only server/public is served), so these are hand-kept copies;
+// remote-relay-shared.test.mjs asserts they behave exactly like the originals.
+
+export const REMOTE_RELAY_PERMISSIONS = Object.freeze(['read', 'prompt', 'full']);
+export const REMOTE_RELAY_DEFAULT_PERMISSION = 'full';
+export const REMOTE_RELAY_SOCKET_EVENT = 'remote_relays_updated';
+
+// The header line a relay puts at the top of a prompt it forwards. The UI
+// hides it on bubbles that carry `origin` (the badge shows the same facts).
+export const REMOTE_PROMPT_HEADER_PATTERN = /^\[Remote prompt from an agent on relay "[^"\r\n]*"[^\r\n]*\](?:\r?\n){1,2}/;
+
+const NAME_CHAR = /[a-z0-9._-]/;
+
+function toText(value) {
+  return String(value ?? '').trim();
+}
+
+function hostOf(url) {
+  try {
+    return new URL(String(url)).hostname.toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+export function normalizeRemoteRelayPermission(value) {
+  const permission = toText(value).toLowerCase();
+  return REMOTE_RELAY_PERMISSIONS.includes(permission) ? permission : REMOTE_RELAY_DEFAULT_PERMISSION;
+}
+
+export function stripRemotePromptHeader(text) {
+  return String(text ?? '').replace(REMOTE_PROMPT_HEADER_PATTERN, '');
+}
+
+/** Link that opens one conversation in a relay's web UI. */
+export function remoteConversationUrl(baseUrl, conversationId) {
+  const base = toText(baseUrl).replace(/\/+$/, '');
+  const id = toText(conversationId);
+  if (!base) return '';
+  return id ? `${base}/?conv=${encodeURIComponent(id)}` : `${base}/`;
+}
+
+/** localhost (and *.localhost), an IPv4 literal, or an IPv6 literal (bracketed as URL hosts are). */
+export function isAddressHost(host) {
+  const value = toText(host).toLowerCase();
+  if (!value) return false;
+  if (value === 'localhost' || value.endsWith('.localhost')) return true;
+  if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(value)) return true;
+  return value.startsWith('[') || value.includes(':');
+}
+
+/** The lowercase aliases a relay can be mentioned by: its name and its URL host, unless that is an address. */
+export function remoteRelayAliases(relay) {
+  const aliases = new Set();
+  const name = toText(relay?.name).toLowerCase();
+  if (name) aliases.add(name);
+  const host = hostOf(relay?.url);
+  if (host && !isAddressHost(host)) aliases.add(host);
+  return [...aliases];
+}
+
+/**
+ * For the composer: the partial `@word` token ending at `caret`, or null.
+ * `{ start, end, query }` where start is the index of the `@`.
+ */
+export function mentionQueryAt(text, caret) {
+  const value = String(text ?? '');
+  const end = Number.isInteger(caret) ? Math.min(Math.max(caret, 0), value.length) : value.length;
+  let start = end;
+  while (start > 0 && NAME_CHAR.test(value[start - 1].toLowerCase())) start -= 1;
+  if (start === 0 || value[start - 1] !== '@') return null;
+  const at = start - 1;
+  if (at > 0 && !/\s|[([{"'`,;]/.test(value[at - 1])) return null;
+  return { start: at, end, query: value.slice(start, end).toLowerCase() };
+}
+
+/** How far the mention token that starts at `from` runs (the rest of a word the caret sits in). */
+export function mentionTokenEnd(text, from) {
+  const value = String(text ?? '');
+  let end = Math.min(Math.max(Number(from) || 0, 0), value.length);
+  while (end < value.length && NAME_CHAR.test(value[end].toLowerCase())) end += 1;
+  return end;
+}