@oar-sh/oar 0.9.12 → 0.9.14

package/server/public/app/host-suspend-ui.js

@@ -6,8 +6,19 @@
 // host action" setting on purpose: a device with the action hidden must still
 // be able to see and cancel a queued suspend.
 
-import { escHtml, showTransientRelayNotice } from './store.js';
-import { cancelHostSuspend, cancelRelayRestart } from './api-client.js';
+import { showTransientRelayNotice } from './store.js';
+import { cancelHostSuspend } from './api-client.js';
+import {
+  cancelQueuedRelayRestart,
+  isRelayRestartRequestInFlight,
+  keepWaitingForQueuedRelayRestart,
+  noteRelayRestartStateForDialogs,
+  openRestartNowConfirmation,
+  refreshRelayRestartWaitedLabels,
+  relayRestartHeadline,
+  renderRelayRestartRow,
+  setRelayRestartStateSink,
+} from './relay-restart-ui.js';
 
 const BANNER_ID = 'pending-action-banner';
 const SUSPEND_MENU_ID = 'chat-menu-suspend-host';
@@ -20,6 +31,7 @@ const RESTART_MENU_PENDING_LABEL = '🌄 Restart pending…';
 let hostSuspendState = null;
 let relayShutdownState = null;
 let countdownTimer = null;
+let waitedTimer = null;
 let cancelInFlight = false;
 
 export function getHostSuspendState() {
@@ -96,20 +108,10 @@ export function hostSuspendBannerText(state, nowMs = Date.now()) {
     : '💤 Suspend queued — waiting for running agents to finish';
 }
 
+/** The restart row's headline (relay-restart-ui.js renders the whole row). */
 export function relayShutdownBannerText(state) {
   if (!isRelayShutdownPending(state)) return '';
-  const action = state.action === 'restart' || state.restart ? 'restart' : 'shutdown';
-  const icon = action === 'restart' ? '🌄' : '⏻';
-  if (String(state.status || '') === 'shutting_down') {
-    return `${icon} Relay ${action === 'restart' ? 'restarting' : 'shutting down'} now…`;
-  }
-  // Only the processing turns hold it; queued messages wait for the restart.
-  const queue = state.queue || {};
-  const turns = Number(queue.processingCount || 0);
-  const held = Number(queue.pendingCount || 0) + Number(queue.parkedCount || 0);
-  const waiting = turns > 0 ? `waiting for ${turns} running turn${turns === 1 ? '' : 's'} to finish` : 'nothing is running, going down now';
-  const queued = held > 0 ? `; ${held} queued message${held === 1 ? '' : 's'} wait${held === 1 ? 's' : ''} for it` : '';
-  return `${icon} Relay ${action} queued — ${waiting}${queued}`;
+  return relayRestartHeadline(state);
 }
 
 function ensureBanner() {
@@ -165,30 +167,6 @@ async function runCancelHostSuspend() {
   }
 }
 
-async function runCancelRelayShutdown() {
-  if (cancelInFlight) return;
-  cancelInFlight = true;
-  renderPendingActionBanner();
-  try {
-    let result = null;
-    try {
-      result = await cancelRelayRestart();
-    } catch (error) {
-      showTransientRelayNotice(`Failed to cancel the queued relay restart: ${error?.message || 'unknown error'}`, 6000);
-      return;
-    }
-    if (!result?.ok) {
-      showTransientRelayNotice('Failed to cancel the queued relay restart.', 5000);
-      return;
-    }
-    applyRelayShutdownState(result);
-    showTransientRelayNotice(result.cancelled ? 'Queued relay restart cancelled.' : 'No relay restart was pending.', 4000);
-  } finally {
-    cancelInFlight = false;
-    renderPendingActionBanner();
-  }
-}
-
 function syncCountdownTimer() {
   const needsTicker = isHostSuspendPending() && String(hostSuspendState?.status || '') === 'countdown' && hostSuspendState?.fireAt;
   if (needsTicker && !countdownTimer) {
@@ -197,8 +175,27 @@ function syncCountdownTimer() {
     clearInterval(countdownTimer);
     countdownTimer = null;
   }
+  // The restart's waited time ticks in place: rebuilding the row every
+  // second would swallow a click on its buttons.
+  const needsWaitedTicker = String(relayShutdownState?.status || '') === 'queued';
+  if (needsWaitedTicker && !waitedTimer) {
+    waitedTimer = setInterval(() => refreshRelayRestartWaitedLabels(relayShutdownState), 15_000);
+    waitedTimer?.unref?.();
+  } else if (!needsWaitedTicker && waitedTimer) {
+    clearInterval(waitedTimer);
+    waitedTimer = null;
+  }
 }
 
+const relayRestartHandlers = {
+  onOpen: (conversationId) => {
+    if (conversationId && typeof window.openConversation === 'function') void window.openConversation(conversationId);
+  },
+  onRestartNow: () => openRestartNowConfirmation(relayShutdownState),
+  onKeepWaiting: () => keepWaitingForQueuedRelayRestart(),
+  onCancel: () => cancelQueuedRelayRestart(),
+};
+
 export function renderPendingActionBanner() {
   if (typeof document === 'undefined') return;
   const rows = [];
@@ -211,12 +208,9 @@ export function renderPendingActionBanner() {
     }));
   }
   if (isRelayShutdownPending()) {
-    const restarting = String(relayShutdownState?.status || '') === 'shutting_down';
-    rows.push(bannerRow({
-      key: 'relay-shutdown',
-      text: relayShutdownBannerText(relayShutdownState),
-      cancelLabel: restarting ? '' : 'Cancel',
-      onCancel: runCancelRelayShutdown,
+    rows.push(renderRelayRestartRow(relayShutdownState, {
+      handlers: relayRestartHandlers,
+      busy: isRelayRestartRequestInFlight(),
     }));
   }
   const banner = document.getElementById(BANNER_ID) || (rows.length ? ensureBanner() : null);
@@ -246,6 +240,7 @@ export function applyHostSuspendState(state) {
 
 export function applyRelayShutdownState(state) {
   relayShutdownState = state && typeof state === 'object' ? state : null;
+  noteRelayRestartStateForDialogs(relayShutdownState);
   renderPendingActionBanner();
 }
 
@@ -268,6 +263,11 @@ export function applyPendingActionsFromStatus(status) {
 }
 
 export function initHostSuspendUi() {
+  // A cancel, keep-waiting or restart-now answer carries the new state.
+  setRelayRestartStateSink((state, { rerenderOnly = false } = {}) => {
+    if (rerenderOnly) renderPendingActionBanner();
+    else applyRelayShutdownState(state);
+  });
   renderPendingActionBanner();
 }
 
@@ -276,6 +276,7 @@ export function __resetHostSuspendUiForTests() {
   relayShutdownState = null;
   cancelInFlight = false;
   if (countdownTimer) { clearInterval(countdownTimer); countdownTimer = null; }
+  if (waitedTimer) { clearInterval(waitedTimer); waitedTimer = null; }
   document.getElementById(BANNER_ID)?.remove();
   syncMenuLabels();
 }

package/server/public/app/journal-view.js

@@ -82,6 +82,7 @@ import { mergeTailPage } from './transcript-reading-anchor.mjs';
 import { readWindowRetention } from './conversation-window-retention.mjs';
 import { MENU_SEPARATOR, bindLongPress, closeContextMenu, openContextMenu } from './context-menu.mjs';
 import {
+  isBackgroundTasksSnapshotCurrent,
   setBackgroundTasksConversation,
   setConversationBackgroundTasks,
   setConversationEndedBackgroundTasks,
@@ -777,6 +778,8 @@ export function toggleConversationGroupFold(event, groupId) {
 // rather than drawn anew (mergeMessagesIntoTranscript).
 // windowPayload: with keepTranscript, the window the page keeps, kept for
 // the next visit in place of nothing.
+// backgroundTasksAsOf: backgroundTasksSnapshotMark(id) as the request left;
+// the payload's task sets are left out when an event brought newer ones since.
 export function applyLoadedConversationState(id, response, {
   restoreScroll = false,
   savedScrollTop = null,
@@ -786,6 +789,7 @@ export function applyLoadedConversationState(id, response, {
   fromCache = false,
   mergeFrom = null,
   windowPayload = null,
+  backgroundTasksAsOf = null,
 } = {}) {
   if (!response) {
     if (!IS_SHARED_VIEW) conversationPayloadCache.forget(id);
@@ -892,9 +896,11 @@ export function applyLoadedConversationState(id, response, {
   setBackgroundTasksConversation(id);
   // Absent from an older relay's payload: the threshold keeps its default.
   if ('taskStallMinutes' in response) setConversationTaskStallMinutes(id, response.taskStallMinutes);
-  setConversationBackgroundTasks(id, response.backgroundTasks || []);
-  // Absent from an older relay's payload: keep what the socket said.
-  if (Array.isArray(response.endedBackgroundTasks)) setConversationEndedBackgroundTasks(id, response.endedBackgroundTasks);
+  if (isBackgroundTasksSnapshotCurrent(id, backgroundTasksAsOf)) {
+    setConversationBackgroundTasks(id, response.backgroundTasks || []);
+    // Absent from an older relay's payload: keep what the socket said.
+    if (Array.isArray(response.endedBackgroundTasks)) setConversationEndedBackgroundTasks(id, response.endedBackgroundTasks);
+  }
   setUsageLimitConversation(id, {
     // Absent from an older relay's payload: keep what the socket said.
     pause: 'usageLimitPause' in response ? response.usageLimitPause : undefined,

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

@@ -11,6 +11,7 @@ const PUSH_EVENT_CONTROL_IDS = {
   board: 'push-event-board-toggle',
   cliOffline: 'push-event-cli-offline-toggle',
   hostSuspend: 'push-event-host-suspend-toggle',
+  relayRestart: 'push-event-relay-restart-toggle',
 };
 
 let pushUpdateInFlight = false;

package/server/public/app/question-answer-rule.mjs

@@ -0,0 +1,15 @@
+// Browser mirror of questionAcceptsFreeText in shared/question-answer-rule.mjs
+// (the relay's answer route applies the same rule). The browser cannot import
+// shared/ (only server/public is served), so this is a hand-kept copy;
+// question-answer-rule.test.mjs asserts it behaves exactly like the original.
+
+/**
+ * Whether a card takes typed text. A card with choices takes it only when it
+ * says so (`allowFreeform: true`); a missing flag counts as false there, as
+ * the create route and the relay's question rows read it. Without choices a
+ * card always does: it could not be answered otherwise.
+ */
+export function questionAcceptsFreeText(question) {
+  const choices = Array.isArray(question?.choices) ? question.choices : [];
+  return question?.allowFreeform === true || choices.length === 0;
+}

package/server/public/app/question-multi-select.mjs

@@ -14,14 +14,21 @@
 // answer is the selected labels joined with ", " — plus whatever the user
 // typed as an extra answer — which is Claude's own multi-select answer format.
 
+import { questionAcceptsFreeText } from './question-answer-rule.mjs';
+
 function choiceCount(question) {
   return Array.isArray(question?.choices) ? question.choices.length : 0;
 }
 
-/** Whether the card offers the "Select several" switch. */
+/**
+ * Whether the card offers the "Select several" switch. Never on a card that
+ * takes no typed text: the relay takes several choices there only when the
+ * provider flagged the card multi-select.
+ */
 export function offersMultiSelectToggle(question) {
   if (!question || typeof question !== 'object') return false;
-  return choiceCount(question) >= 2 && question?.context?.allowMultiSelect === true;
+  return choiceCount(question) >= 2 && question?.context?.allowMultiSelect === true
+    && questionAcceptsFreeText(question);
 }
 
 /**

package/server/public/app/relay-event-view.mjs

@@ -24,6 +24,7 @@ const EVENT_TYPES = new Set([
   'heartbeat',
   'link_lost',
   'link_restored',
+  'relay_restarted',
 ]);
 const URGENT_TYPES = new Set(['question_asked', 'error']);
 const DIGEST_PATTERN = /^Digest of \d+ events?/;
@@ -43,6 +44,7 @@ const TYPE_LABELS = Object.freeze({
   heartbeat: 'heartbeat',
   link_lost: 'link lost',
   link_restored: 'link back',
+  relay_restarted: 'relay restarted',
 });
 
 function defaultEscape(value) {
@@ -181,6 +183,8 @@ export function watchersOf(subscriptions, conversationId, { includeAll = true }
 export function watchingChipText(summary) {
   if (!summary?.subscriptions?.length) return '';
   if (summary.all) return summary.count ? `watching all sessions (+${summary.count} listed)` : 'watching all sessions';
+  // Only relay_restarted: no session is watched.
+  if (!summary.count) return 'waiting for a relay restart';
   return `watching ${summary.count} session${summary.count === 1 ? '' : 's'}`;
 }
 
@@ -198,7 +202,7 @@ function describeSubscription(sub, conversations) {
   const listed = (Array.isArray(sub.sessions) ? sub.sessions : []).filter((session) => session?.id).map(titleOf).join(', ');
   const what = sub.scope === 'all'
     ? (paired ? `All sessions of ${relay}` : 'All sessions')
-    : (paired ? `${relay} · ${listed}` : listed);
+    : (paired ? `${relay} · ${listed}` : (listed || 'This relay'));
   const extras = [
     sub.once ? 'once' : '',
     sub.heartbeatMinutes ? `heartbeat ${sub.heartbeatMinutes} min` : '',

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

@@ -1,6 +1,6 @@
 import { stripRemotePromptHeader } from './remote-relay-shared.mjs';
 
-const RELAY_TOOL_GUIDANCE = [
+const RELAY_TOOL_GUIDANCE_LINES = [
   '# 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.',
   'When using ask_user, ALWAYS include a `choices` array with 2-6 answer options so the web relay can render clickable buttons. Only omit choices when the question genuinely requires freeform text input.',
@@ -8,7 +8,12 @@ const RELAY_TOOL_GUIDANCE = [
   'For relay restarts in extension-managed mode, require explicit user permission first, then use the authenticated localhost API `POST /api/relay/shutdown`. Do not restart by killing processes or using respawn scripts.',
   'Note: shutdown is queued and only completes when the current turn finishes, so it is pointless to wait for it to interrupt an active turn.',
   'Use `restart: true` in the request body when the user wants a real relay restart rather than a plain shutdown. Example request body: `{ "reason": "manual-restart", "requestedBy": "localhost-api", "restart": true }`.',
-].join(' ');
+  'Never pass `immediate` in that request body: it restarts without waiting for the running turns, which only the user may decide, with Restart now in the web UI.',
+];
+const RELAY_TOOL_GUIDANCE = RELAY_TOOL_GUIDANCE_LINES.join(' ');
+// Prompts stored before the `immediate` line was added carry the guidance
+// without it.
+const PREVIOUS_RELAY_TOOL_GUIDANCE = RELAY_TOOL_GUIDANCE_LINES.slice(0, -1).join(' ');
 
 const MODE_MARKERS = {
   plan: '[Relay mode: plan]',
@@ -94,6 +99,8 @@ function buildPromptPrefixPatterns(mode) {
     return [
       new RegExp(`^${whitespaceFlexiblePattern(currentFullPrefix)}\\s*`, 'i'),
       new RegExp(`^${whitespaceFlexiblePattern(legacyFullPrefix)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(`${marker} ${MODE_INSTRUCTIONS[key]} ${PREVIOUS_RELAY_TOOL_GUIDANCE}`)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(`${marker} ${LEGACY_MODE_INSTRUCTIONS[key]} ${PREVIOUS_RELAY_TOOL_GUIDANCE}`)}\\s*`, 'i'),
       new RegExp(`^${whitespaceFlexiblePattern(marker)}\\s*`, 'i'),
     ];
   });

package/server/public/app/relay-restart-note-view.mjs

@@ -0,0 +1,36 @@
+// The note the relay writes into a conversation whose turn a relay restart
+// cut off ("After a relay restart, tell interrupted sessions to carry on",
+// server/services/restart-resume-service.mjs): a compact row in the look of
+// the relay event rows, never a bubble of the user's.
+//
+// DOM-free, like relay-event-view.mjs: the caller owns the element.
+
+export const RESTART_RESUME_KIND = 'relay-restart-resume';
+export const RESTART_RESUME_LEAD = 'Automatic message from OAR, not from the user:';
+
+function defaultEscape(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+export function isRestartResumeNote(message) {
+  return message?.role === 'user' && String(message?.kind || '').trim() === RESTART_RESUME_KIND;
+}
+
+/** The row's markup: folded to one line, opened to the note as the agent got it. */
+export function renderRestartResumeNoteHtml(message, { escHtml = defaultEscape, timeText = '' } = {}) {
+  const text = String(message?.text ?? '').trim();
+  const body = text.startsWith(RESTART_RESUME_LEAD) ? text.slice(RESTART_RESUME_LEAD.length).trim() : text;
+  return '<details class="relay-event-row relay-restart-note">'
+    + '<summary class="relay-event-summary">'
+    + '<span class="relay-event-tag" title="An automated message of the relay, not from you.">relay</span>'
+    + '<span class="relay-event-text">Relay restarted · the interrupted turn was asked to carry on</span>'
+    + (timeText ? `<span class="relay-event-time">${escHtml(timeText)}</span>` : '')
+    + '</summary>'
+    + `<div class="relay-event-lines relay-restart-note-text">${escHtml(body)}</div>`
+    + '</details>';
+}