@oar-sh/oar 0.9.10 → 0.9.12

package/server/public/app/settings-modal.js

@@ -29,6 +29,8 @@ import {
   updateTurnCeilingSetting as requestTurnCeilingSetting,
   loadBackgroundTaskTimeoutSetting,
   updateBackgroundTaskTimeoutSetting as requestBackgroundTaskTimeoutSetting,
+  loadTaskStallMinutesSetting,
+  updateTaskStallMinutesSetting as requestTaskStallMinutesSetting,
   loadSubagentRecordRetentionSetting,
   updateSubagentRecordRetentionSetting as requestSubagentRecordRetentionSetting,
   loadFeatureFlagSettings,
@@ -36,6 +38,13 @@ import {
   requestRelayRestart,
 } from './api-client.js';
 import { DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES } from './background-task-timeout-options.mjs';
+import {
+  DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MINUTES,
+  formatClaudeBackgroundCommandLimitLabel,
+} from './claude-background-command-limit-options.mjs';
+import { DEFAULT_TASK_STALL_MINUTES } from './task-console-render.mjs';
+import { setTaskStallThreshold } from './background-tasks-view.mjs';
+import { describeRelayRestartError } from './relay-restart-error.mjs';
 import { syncFontScaleSelect } from './font-scaling.js';
 import { syncInstalledAppUiState, syncPwaAppNameInput } from './pwa-install.js';
 import { normalizeKnownCwdPath } from './cwd-picker.js';
@@ -48,6 +57,9 @@ import { refreshCliInstallSections } from './cli-install-ui.js';
 import { refreshUpdateSection } from './update-ui.js';
 import { refreshRemoteRelaysSection } from './remote-relays-settings.js';
 import { refreshAgentSessionsSection } from './agent-sessions-settings-ui.js';
+import { refreshSharedConversationsSection } from './shared-conversations-settings.js';
+import { syncScrollOnSendToggle } from './transcript-jump-bottom.mjs';
+import { syncWindowRetentionSlider } from './conversation-window-retention.mjs';
 import {
   getPreviews,
   renderPreviewRowsInto,
@@ -199,6 +211,74 @@ export async function refreshBackgroundTaskTimeoutSetting() {
   }
 }
 
+// Minutes without output after which a background task's row turns amber.
+// Starts at the relay's default; bounds come from the API response.
+let taskStallMinutes = DEFAULT_TASK_STALL_MINUTES;
+let taskStallMinutesUpdateInFlight = false;
+
+export function formatTaskStallMinutesLabel(value) {
+  const minutes = Math.max(1, Math.round(Number(value) || DEFAULT_TASK_STALL_MINUTES));
+  return `${minutes} min`;
+}
+
+function syncTaskStallMinutesSlider() {
+  const slider = document.getElementById('task-stall-minutes-slider');
+  const label = document.getElementById('task-stall-minutes-value');
+  if (slider instanceof HTMLInputElement) {
+    slider.value = String(taskStallMinutes);
+    slider.disabled = taskStallMinutesUpdateInFlight;
+  }
+  if (label) label.textContent = formatTaskStallMinutesLabel(taskStallMinutes);
+}
+
+/** Live label feedback while dragging; nothing is persisted until change fires. */
+export function previewTaskStallMinutesSetting(value) {
+  const label = document.getElementById('task-stall-minutes-value');
+  if (label) label.textContent = formatTaskStallMinutesLabel(value);
+}
+
+export async function refreshTaskStallMinutesSetting() {
+  syncTaskStallMinutesSlider();
+  try {
+    const result = await loadTaskStallMinutesSetting();
+    if (!result || !Number.isFinite(Number(result.minutes))) return;
+    taskStallMinutes = Number(result.minutes);
+    setTaskStallThreshold(taskStallMinutes);
+    const slider = document.getElementById('task-stall-minutes-slider');
+    if (slider instanceof HTMLInputElement) {
+      if (Number.isFinite(Number(result.min))) slider.min = String(result.min);
+      if (Number.isFinite(Number(result.max))) slider.max = String(result.max);
+    }
+  } catch {
+    // Keep the last known value; the setting is not critical.
+  } finally {
+    syncTaskStallMinutesSlider();
+  }
+}
+
+export async function updateTaskStallMinutesSetting(value) {
+  if (taskStallMinutesUpdateInFlight) {
+    syncTaskStallMinutesSlider();
+    return;
+  }
+  const requested = Math.max(1, Math.round(Number(value) || DEFAULT_TASK_STALL_MINUTES));
+  taskStallMinutesUpdateInFlight = true;
+  syncTaskStallMinutesSlider();
+  try {
+    const result = await requestTaskStallMinutesSetting(requested);
+    if (!result) throw new Error('Failed to update when a background task counts as quiet.');
+    taskStallMinutes = Number.isFinite(Number(result.minutes)) ? Number(result.minutes) : requested;
+    // The open conversation's rows follow at once, not on the next load.
+    setTaskStallThreshold(taskStallMinutes);
+    showTransientRelayNotice(`Background tasks are marked as quiet after ${formatTaskStallMinutesLabel(taskStallMinutes)} without output.`);
+  } catch (error) {
+    alert(error?.message || 'Failed to update when a background task counts as quiet.');
+  } finally {
+    taskStallMinutesUpdateInFlight = false;
+    syncTaskStallMinutesSlider();
+  }
+}
+
 // Mirrors shared/subagent-record-retention.mjs (the browser cannot import it):
 // the select starts at the relay's default until the relay's value loads.
 const DEFAULT_SUBAGENT_RECORD_RETENTION_DAYS = 90;
@@ -476,6 +556,7 @@ let claudeSettingsState = {
   enabled: false,
   model: 'claude-sonnet-5',
   models: [],
+  backgroundCommandLimitMinutes: DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MINUTES,
 };
 let claudeSettingsInputsDirty = false;
 
@@ -489,7 +570,7 @@ function ensureClaudeSettingsInputTracking() {
 }
 
 function setClaudeSettingsControlsDisabled(disabled) {
-  for (const id of ['claude-model-input', 'claude-enabled-toggle', 'claude-attribution-select', 'claude-save-btn']) {
+  for (const id of ['claude-model-input', 'claude-enabled-toggle', 'claude-attribution-select', 'claude-background-command-limit-slider', 'claude-save-btn']) {
     const element = document.getElementById(id);
     if (element) element.disabled = disabled;
   }
@@ -504,6 +585,9 @@ export function applyClaudeSettingsState(settings = {}, { resetInputs = false }
     models: Array.isArray(settings?.models) ? settings.models : claudeSettingsState.models,
     attributionMode: ['oar', 'vanilla', 'off'].includes(settings?.attributionMode) ? settings.attributionMode : (claudeSettingsState.attributionMode || 'oar'),
     attributionExample: String(settings?.attributionExample || claudeSettingsState.attributionExample || '').trim(),
+    backgroundCommandLimitMinutes: Number(settings?.backgroundCommandLimitMinutes) > 0
+      ? Number(settings.backgroundCommandLimitMinutes)
+      : (claudeSettingsState.backgroundCommandLimitMinutes || DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MINUTES),
   };
   const modelInput = document.getElementById('claude-model-input');
   const toggle = document.getElementById('claude-enabled-toggle');
@@ -511,6 +595,15 @@ export function applyClaudeSettingsState(settings = {}, { resetInputs = false }
   const attributionSelect = document.getElementById('claude-attribution-select');
   if (attributionSelect && (!claudeSettingsInputsDirty || resetInputs)) attributionSelect.value = claudeSettingsState.attributionMode;
   renderClaudeAttributionExample(attributionSelect?.value || claudeSettingsState.attributionMode);
+  const limitSlider = document.getElementById('claude-background-command-limit-slider');
+  if (limitSlider instanceof HTMLInputElement) {
+    // Bounds come from the relay; the markup's are only the pre-load copy.
+    for (const [attribute, field] of [['min', 'backgroundCommandLimitMinMinutes'], ['max', 'backgroundCommandLimitMaxMinutes'], ['step', 'backgroundCommandLimitStepMinutes']]) {
+      if (Number(settings?.[field]) > 0) limitSlider[attribute] = String(settings[field]);
+    }
+    if (!claudeSettingsInputsDirty || resetInputs) limitSlider.value = String(claudeSettingsState.backgroundCommandLimitMinutes);
+  }
+  renderClaudeBackgroundCommandLimitLabel(limitSlider?.value || claudeSettingsState.backgroundCommandLimitMinutes);
   if (modelInput && (!claudeSettingsInputsDirty || resetInputs)) modelInput.value = claudeSettingsState.model;
   if (resetInputs) claudeSettingsInputsDirty = false;
   if (toggle) {
@@ -558,6 +651,19 @@ function renderClaudeAttributionExample(mode) {
   example.textContent = claudeAttributionExampleText(mode, claudeSettingsState.attributionExample);
 }
 
+function renderClaudeBackgroundCommandLimitLabel(minutes) {
+  const label = document.getElementById('claude-background-command-limit-value');
+  if (label) label.textContent = formatClaudeBackgroundCommandLimitLabel(minutes);
+}
+
+/** Live label feedback while dragging; saved with the other Claude settings. */
+export function previewClaudeBackgroundCommandLimit(value) {
+  claudeSettingsInputsDirty = true;
+  renderClaudeBackgroundCommandLimitLabel(value);
+}
+
+window.previewClaudeBackgroundCommandLimit = previewClaudeBackgroundCommandLimit;
+
 window.previewClaudeAttribution = (mode) => {
   claudeSettingsInputsDirty = true;
   renderClaudeAttributionExample(mode);
@@ -569,10 +675,12 @@ export async function saveClaudeSettings() {
   const model = String(modelInput?.value || '').trim() || 'claude-sonnet-5';
   const attributionSelect = document.getElementById('claude-attribution-select');
   const attributionMode = ['oar', 'vanilla', 'off'].includes(attributionSelect?.value) ? attributionSelect.value : undefined;
+  const limitSlider = document.getElementById('claude-background-command-limit-slider');
+  const backgroundCommandLimitMinutes = Number(limitSlider?.value) > 0 ? Number(limitSlider.value) : undefined;
   claudeSettingsUpdateInFlight = true;
   setClaudeSettingsControlsDisabled(true);
   try {
-    const result = await updateClaudeSettings({ model, attributionMode });
+    const result = await updateClaudeSettings({ model, attributionMode, backgroundCommandLimitMinutes });
     if (!result) throw new Error('Failed to save Claude settings.');
     applyClaudeSettingsState(result, { resetInputs: true });
     showTransientRelayNotice(
@@ -1337,15 +1445,33 @@ export async function removeOpenAISettings() {
   }
 }
 
+const WINDOWS_BOOT_CUSTOMISATION_LABELS = Object.freeze({
+  action: 'what it runs',
+  'working-directory': 'working folder',
+  'logon-type': 'logon type',
+  trigger: 'trigger',
+  'boot-delay': 'boot delay',
+  launcher: 'launcher edited or from an older OAR',
+  'launcher-missing': 'launcher missing',
+});
+
 function windowsAutostartStatusText() {
   const boot = windowsAutostartState?.boot;
   if (boot?.pendingElevation) {
     return 'Confirm the admin prompt on the PC… (it only appears on the physical desktop)';
   }
   if (boot?.lastError) return boot.lastError;
+  if (boot?.readError) return `The boot task could not be read: ${boot.readError}`;
   if (windowsAutostartState?.mode === 'boot' && windowsAutostartState?.signinEnabled) {
     return 'A sign-in Startup entry also exists and can double-start the relay. Re-select "At system startup" to clean it up.';
   }
+  if (windowsAutostartState?.mode === 'boot' && boot?.customised) {
+    const labels = (boot.customisations || []).map((name) => WINDOWS_BOOT_CUSTOMISATION_LABELS[name] || name);
+    return `The boot task or its launcher differs from what OAR generates (${labels.join(', ')}). Re-selecting "At system startup" regenerates both and keeps a changed launcher as a .bak copy.`;
+  }
+  if (windowsAutostartState?.mode === 'boot' && boot?.launcherBackupPath) {
+    return `The previous launcher was replaced and kept as ${boot.launcherBackupPath}.`;
+  }
   if (boot?.taskStatus === 'foreign') {
     return `A task named "${boot.taskName}" exists but was not created by OAR. Selecting "At system startup" replaces it.`;
   }
@@ -1425,7 +1551,7 @@ export async function refreshWindowsAutostartSetting() {
     }
     windowsAutostartState = result;
   } catch (error) {
-    alert(error?.message || 'Failed to read the Windows autostart setting.');
+    alert(error?.message ? `Failed to read the Windows autostart setting: ${error.message}` : 'Failed to read the Windows autostart setting.');
   } finally {
     windowsAutostartUpdateInFlight = false;
     syncWindowsAutostartSetting();
@@ -1459,7 +1585,7 @@ export async function updateWindowsAutostartMode(mode) {
       );
     }
   } catch (error) {
-    alert(error?.message || 'Failed to update the Windows autostart setting.');
+    alert(error?.message ? `Failed to update the Windows autostart setting: ${error.message}` : 'Failed to update the Windows autostart setting.');
   } finally {
     windowsAutostartUpdateInFlight = false;
     syncWindowsAutostartSetting();
@@ -1579,9 +1705,17 @@ async function restartRelayForFeatureFlags() {
   featureFlagsUpdateInFlight = true;
   syncFeatureFlagsSection();
   try {
-    const result = await requestRelayRestart({ reason: 'feature-flags-changed' });
-    if (!result) {
-      alert('Failed to request a relay restart. Restarts can only be requested from the relay host itself.');
+    let result = null;
+    try {
+      result = await requestRelayRestart({ reason: 'feature-flags-changed' });
+    } catch (error) {
+      const { kind, text } = describeRelayRestartError(error);
+      if (kind === 'refused') alert(text);
+      else showTransientRelayNotice(text, 9000);
+      return;
+    }
+    if (!result?.ok) {
+      alert('Failed to request a relay restart.');
       return;
     }
     showTransientRelayNotice('Relay restart requested. It will restart once the running turns finish; queued messages wait for it.');
@@ -1684,14 +1818,15 @@ export async function updateDefaultSessionWorkspaceRootSetting(rawValue) {
 }
 
 // "Live previews": every preview across every session, not just this
-// conversation's. Previews never expire, so this list is the one place that can
-// close a link left behind in a conversation you have moved on from.
+// conversation's. Previews never expire and survive a relay restart, so this
+// list is the one place that can close a link left behind in a conversation
+// you have moved on from; age and last use show which ones are stale.
 export function renderPreviewsSection() {
   const list = document.getElementById('settings-previews-list');
   const empty = document.getElementById('settings-previews-empty');
   if (!list) return;
   const previews = getPreviews();
-  renderPreviewRowsInto(list, previews, { withConversation: true });
+  renderPreviewRowsInto(list, previews, { withConversation: true, withAge: true });
   if (empty) {
     empty.hidden = previews.length > 0;
     empty.textContent = 'No previews are published right now.';
@@ -1726,6 +1861,8 @@ export function openSettingsModal(tab, providerTab) {
     themeSelect.value = readLocalStorage(THEME_STORAGE_KEY) === 'light' ? 'light' : 'dark';
   }
   syncSuspendHostVisibility();
+  syncScrollOnSendToggle();
+  syncWindowRetentionSlider();
   syncFontScaleSelect();
   syncPwaAppNameInput();
   syncDefaultSessionWorkspaceRootInput();
@@ -1758,10 +1895,13 @@ export function openSettingsModal(tab, providerTab) {
   void refreshTurnCeilingSetting();
   syncBackgroundTaskTimeoutSlider();
   void refreshBackgroundTaskTimeoutSetting();
+  syncTaskStallMinutesSlider();
+  void refreshTaskStallMinutesSetting();
   syncSubagentRecordRetentionSelect();
   void refreshSubagentRecordRetentionSetting();
   void refreshPushSettingsSection();
   void refreshPreviewsSection();
+  void refreshSharedConversationsSection();
   void refreshRemoteRelaysSection();
   void refreshAgentSessionsSection();
   void refreshFeatureFlagsSection();

package/server/public/app/settings-tabs.js

@@ -1,7 +1,7 @@
 const SETTINGS_TAB_STORAGE_KEY = 'copilot_settings_tab';
 const SETTINGS_PROVIDER_TAB_STORAGE_KEY = 'copilot_settings_provider_tab';
 
-const SETTINGS_TABS = ['general', 'providers', 'relays', 'previews', 'notifications', 'features'];
+const SETTINGS_TABS = ['general', 'providers', 'relays', 'previews', 'shares', 'notifications', 'features'];
 // Copilot leads: it is the default provider, and `SETTINGS_PROVIDER_TABS[0]`
 // is also the sub-tab a first-time visitor lands on.
 const SETTINGS_PROVIDER_TABS = ['copilot', 'openai', 'claude', 'claude-cloud', 'grok', 'cursor'];

package/server/public/app/share-format.mjs

@@ -0,0 +1,49 @@
+// Text for Settings → Sharing: a share row's detail line and an access log
+// entry. DOM-free so it is unit-testable.
+
+// The same steps as a preview's age (preview-cards.mjs), which this module
+// cannot import without the API client.
+function age(iso, now) {
+  const at = Date.parse(String(iso || ''));
+  if (!Number.isFinite(at) || at <= 0) return '';
+  const minutes = Math.floor(Math.max(0, now - at) / 60_000);
+  if (minutes < 1) return 'just now';
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours} h ago`;
+  return `${Math.floor(hours / 24)} d ago`;
+}
+
+function plural(count, one, many) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+
+/** "shared 3 d ago · new link 2 h ago · last opened 5 min ago · 4 opens · 2 viewers" */
+export function describeShare(share, now = Date.now()) {
+  const parts = [];
+  const since = age(share?.sharedSince, now);
+  if (since) parts.push(`shared ${since}`);
+  const renewed = age(share?.renewedAt, now);
+  if (renewed) parts.push(`new link ${renewed}`);
+  const opened = age(share?.lastOpenedAt, now);
+  parts.push(opened ? `last opened ${opened}` : 'never opened');
+  const opens = Math.max(0, Math.trunc(Number(share?.openCount) || 0));
+  const viewers = Math.max(0, Math.trunc(Number(share?.viewerCount) || 0));
+  parts.push(plural(opens, 'open', 'opens'));
+  parts.push(plural(viewers, 'viewer', 'viewers'));
+  if (share?.archived) parts.push('archived');
+  return parts.join(' · ');
+}
+
+/** "16 Oct 2026, 14:05 · DE · 203.0.113.7 · viewer 1a2b3c4d" */
+export function describeShareOpen(open, { locale } = {}) {
+  const parts = [];
+  const at = Date.parse(String(open?.openedAt || ''));
+  if (Number.isFinite(at)) {
+    parts.push(new Date(at).toLocaleString(locale, { dateStyle: 'medium', timeStyle: 'short' }));
+  }
+  if (open?.country) parts.push(String(open.country));
+  parts.push(open?.ip ? String(open.ip) : 'IP not stored');
+  if (open?.viewer) parts.push(`viewer ${open.viewer}`);
+  return parts.join(' · ');
+}

package/server/public/app/share-preview-marks.mjs

@@ -0,0 +1,167 @@
+// "Preview as shared": the relay marks, in the payload of its preview routes,
+// every redaction (U+E000 … U+E001, the text a viewer gets in between) and
+// every leftover that still looks like a path (U+E002 … U+E003). See
+// server/services/share-path-redaction.mjs. This module turns the marks into
+// highlights wherever the transcript put the text: reply markdown, thoughts,
+// tool lines, code blocks, the sub-agent viewer. A highlight can be split by
+// the elements a renderer put inside it (syntax highlighting); each piece is
+// marked on its own. Marks inside attributes (a title, a link) are dropped.
+
+export const PREVIEW_MARK_CHARS = Object.freeze({
+  redactedStart: '',
+  redactedEnd: '',
+  suspectStart: '',
+  suspectEnd: '',
+});
+
+const ANY_MARK_RE = /[-]/;
+const ALL_MARKS_RE = /[-]/g;
+const BLOCK_SELECTOR = 'p, li, pre, div, td, th, h1, h2, h3, h4, h5, h6, blockquote, summary';
+const MARK_KINDS = {
+  '': { open: 'redacted' },
+  '': { close: 'redacted' },
+  '': { open: 'suspect' },
+  '': { close: 'suspect' },
+};
+const CLASS_BY_KIND = {
+  redacted: 'share-preview-redacted',
+  suspect: 'share-preview-suspect',
+};
+const TITLE_BY_KIND = {
+  redacted: 'Hidden from shared viewers: they see this instead',
+  suspect: 'Still looks like a path: shared viewers see it as it is',
+};
+
+/** The text without any mark. */
+export function stripPreviewMarks(text) {
+  return String(text ?? '').replace(ALL_MARKS_RE, '');
+}
+
+/**
+ * The pieces of a text between marks, each with the highlight it stands in
+ * (null for plain text). `state` carries an open highlight from the text
+ * before (a highlight split across nodes) and is updated in place.
+ */
+export function splitPreviewMarks(text, state = { kind: null }) {
+  const pieces = [];
+  let buffer = '';
+  const flush = () => {
+    if (buffer) pieces.push({ text: buffer, kind: state.kind });
+    buffer = '';
+  };
+  for (const ch of String(text ?? '')) {
+    const mark = MARK_KINDS[ch];
+    if (!mark) {
+      buffer += ch;
+      continue;
+    }
+    flush();
+    if (mark.open) state.kind = mark.open;
+    else if (mark.close && state.kind === mark.close) state.kind = null;
+  }
+  flush();
+  return pieces;
+}
+
+function markElement(doc, piece) {
+  const element = doc.createElement('mark');
+  element.className = CLASS_BY_KIND[piece.kind];
+  element.title = TITLE_BY_KIND[piece.kind];
+  element.textContent = piece.text;
+  return element;
+}
+
+function rewriteTextNode(node, state) {
+  const value = node.nodeValue || '';
+  if (!ANY_MARK_RE.test(value) && !state.kind) return;
+  const pieces = splitPreviewMarks(value, state);
+  const doc = node.ownerDocument;
+  const fragment = doc.createDocumentFragment();
+  for (const piece of pieces) {
+    fragment.appendChild(piece.kind ? markElement(doc, piece) : doc.createTextNode(piece.text));
+  }
+  node.parentNode?.replaceChild(fragment, node);
+}
+
+function stripAttributes(root) {
+  const elements = root.nodeType === 1 ? [root, ...root.querySelectorAll('*')] : [...(root.querySelectorAll?.('*') || [])];
+  for (const element of elements) {
+    for (const attribute of [...(element.attributes || [])]) {
+      if (ANY_MARK_RE.test(attribute.value)) element.setAttribute(attribute.name, stripPreviewMarks(attribute.value));
+    }
+  }
+}
+
+/** Turn every mark under `root` into a highlight. Idempotent. */
+export function applyPreviewMarks(root) {
+  if (!root) return;
+  if (root.nodeType === 3) {
+    if (root.parentElement) applyPreviewMarks(root.parentElement);
+    return;
+  }
+  const doc = root.ownerDocument || root;
+  if (ANY_MARK_RE.test(root.textContent || '')) {
+    const walker = doc.createTreeWalker(root, 4 /* NodeFilter.SHOW_TEXT */, {
+      acceptNode(node) {
+        const tag = String(node.parentElement?.tagName || '').toUpperCase();
+        // Mark characters are never part of a script or a style; leave them.
+        return tag === 'SCRIPT' || tag === 'STYLE' ? 2 /* FILTER_REJECT */ : 1 /* FILTER_ACCEPT */;
+      },
+    });
+    const nodes = [];
+    while (walker.nextNode()) nodes.push(walker.currentNode);
+    // An open highlight runs on in document order; a block element ends it.
+    let state = { kind: null };
+    let block = null;
+    for (const node of nodes) {
+      const nodeBlock = node.parentElement?.closest?.(BLOCK_SELECTOR) || null;
+      if (nodeBlock !== block) {
+        state = { kind: null };
+        block = nodeBlock;
+      }
+      rewriteTextNode(node, state);
+    }
+  }
+  stripAttributes(root);
+}
+
+/**
+ * Keep marking whatever the page renders under `root` (the transcript is
+ * rebuilt as the preview polls, the sub-agent viewer fills in). Only what
+ * changed is looked at. Returns a stop function.
+ */
+export function watchPreviewMarks(root, { schedule = (fn) => requestAnimationFrame(fn) } = {}) {
+  if (!root || typeof MutationObserver !== 'function') return () => {};
+  const changed = new Set();
+  let pending = false;
+  let observer = null;
+  const observe = () => observer.observe(root, {
+    childList: true, subtree: true, characterData: true, attributes: true,
+  });
+  const run = () => {
+    pending = false;
+    observer.disconnect();
+    try {
+      for (const node of changed) {
+        if (node.isConnected) applyPreviewMarks(node);
+      }
+      changed.clear();
+      if (ANY_MARK_RE.test(document.title || '')) document.title = stripPreviewMarks(document.title);
+    } finally {
+      observe();
+    }
+  };
+  observer = new MutationObserver((records) => {
+    for (const record of records) {
+      if (record.type === 'childList') record.addedNodes.forEach((node) => changed.add(node));
+      else if (record.type === 'characterData') changed.add(record.target);
+      else if (record.type === 'attributes' && ANY_MARK_RE.test(record.target.getAttribute?.(record.attributeName) || '')) changed.add(record.target);
+    }
+    if (pending || !changed.size) return;
+    pending = true;
+    schedule(run);
+  });
+  applyPreviewMarks(root);
+  observe();
+  return () => observer.disconnect();
+}

package/server/public/app/share-state.js

@@ -0,0 +1,109 @@
+// The relay's active public shares, as it last reported them: one entry per
+// shared conversation (Settings → Shared conversations) and whether the open
+// conversation has one (the ⋯ menu's "Stop sharing"). Read from GET /api/shares
+// when the socket connects and again on every share event; no DOM here.
+
+import { listConversationShares } from './api-client.js';
+
+let shares = [];
+let settings = { storeViewerIp: true, accessLog: true };
+let loaded = false;
+let refreshInFlight = null;
+let refreshAgain = false;
+const listeners = new Set();
+
+function notify() {
+  for (const listener of listeners) {
+    try { listener(); } catch (error) { console.error('share listener failed', error); }
+  }
+}
+
+function normalizeShare(entry) {
+  const conversationId = String(entry?.conversationId || '').trim();
+  if (!conversationId) return null;
+  const count = (value) => (Number.isFinite(Number(value)) ? Math.max(0, Math.trunc(Number(value))) : 0);
+  return {
+    conversationId,
+    title: String(entry?.title || '').trim(),
+    archived: entry?.archived === true,
+    shareUrl: String(entry?.shareUrl || '').trim(),
+    sharedSince: entry?.sharedSince || null,
+    renewedAt: entry?.renewedAt || null,
+    lastOpenedAt: entry?.lastOpenedAt || null,
+    openCount: count(entry?.openCount),
+    viewerCount: count(entry?.viewerCount),
+  };
+}
+
+/** Takes a GET /api/shares body (or the same shape). */
+export function applySharesSnapshot(payload) {
+  if (!payload || typeof payload !== 'object') return;
+  shares = (Array.isArray(payload.shares) ? payload.shares : []).map(normalizeShare).filter(Boolean);
+  settings = {
+    storeViewerIp: payload.storeViewerIp !== false,
+    accessLog: payload.accessLog !== false,
+  };
+  loaded = true;
+  notify();
+}
+
+export function applyShareSettings(next) {
+  if (!next || typeof next.storeViewerIp !== 'boolean') return;
+  settings = { ...settings, storeViewerIp: next.storeViewerIp };
+  notify();
+}
+
+/** A share this page just stopped: gone before the relay's event arrives. */
+export function forgetShare(conversationId) {
+  const id = String(conversationId || '').trim();
+  const next = shares.filter((share) => share.conversationId !== id);
+  if (next.length === shares.length) return;
+  shares = next;
+  notify();
+}
+
+export function getShares() {
+  return shares.slice();
+}
+
+export function getShareSettings() {
+  return { ...settings };
+}
+
+export function sharesLoaded() {
+  return loaded;
+}
+
+export function hasActiveShare(conversationId) {
+  const id = String(conversationId || '').trim();
+  return !!id && shares.some((share) => share.conversationId === id);
+}
+
+/**
+ * Reads the list again. Calls during a read are folded into one more read
+ * after it, so the last event always wins. Rejects with the relay's reason.
+ */
+export async function refreshShares() {
+  if (refreshInFlight) {
+    refreshAgain = true;
+    return refreshInFlight;
+  }
+  refreshInFlight = (async () => {
+    try {
+      do {
+        refreshAgain = false;
+        const payload = await listConversationShares();
+        if (payload) applySharesSnapshot(payload);
+      } while (refreshAgain);
+    } finally {
+      refreshInFlight = null;
+    }
+  })();
+  return refreshInFlight;
+}
+
+export function subscribeShares(listener) {
+  if (typeof listener !== 'function') return () => {};
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}