@oar-sh/oar 0.9.0

package/server/public/app/action-confirmations.js

@@ -0,0 +1,267 @@
+import {
+  currentConvId,
+  conversations,
+  escHtml,
+  openSummaryModal,
+  closeSummaryModal,
+  setSummaryModalLoading,
+  showTransientRelayNotice,
+} from './store.js';
+import {
+  killSessionWorker,
+  requestRelayRestart,
+  requestHostSuspend,
+  requestQueueEmpty,
+  refreshWorkspaceRootHints,
+} from './api-client.js';
+import { isSuspendHostActionVisible } from './settings-modal.js';
+
+let killSessionInFlight = false;
+let restartRelayInFlight = false;
+let suspendHostInFlight = false;
+let emptyQueueInFlight = false;
+
+let menuDeps = {
+  lockChatActionsMenuShield: () => {},
+  closeChatActionsMenu: () => {},
+  syncQueueStatusMenuEntry: () => {},
+  refreshSessionWorkerStatus: () => Promise.resolve(),
+};
+
+function getCurrentConversationSessionInfo() {
+  const convId = String(currentConvId || '').trim();
+  if (!convId) return null;
+  const conversation = conversations[convId] || {};
+  const sdkSessionId = String(conversation.sdkSessionId || '').trim();
+  if (!sdkSessionId) return null;
+  const title = String(conversation.title || document.getElementById('chat-title')?.textContent || convId).trim() || convId;
+  return {
+    conversationId: convId,
+    sdkSessionId,
+    title,
+  };
+}
+
+export function openKillSessionConfirmation() {
+  const info = getCurrentConversationSessionInfo();
+  if (!info) {
+    showTransientRelayNotice('No active session is bound to this conversation.');
+    return;
+  }
+  const escapedTitle = escHtml(info.title);
+  openSummaryModal({
+    title: 'Kill session',
+    subtitle: info.sdkSessionId,
+    kind: 'kill-session',
+    bodyHtml: `
+      <p>Kill the session for <strong>${escapedTitle}</strong>?</p>
+      <p>This stops the current worker and any active turn will need a manual retry or a new message.</p>
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn danger-btn" type="button" onclick="confirmKillCurrentSession()">☠️ Kill session</button>
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
+      </div>
+    `,
+  });
+}
+
+export async function confirmKillCurrentSession() {
+  if (killSessionInFlight) return;
+  const info = getCurrentConversationSessionInfo();
+  if (!info) {
+    closeSummaryModal();
+    showTransientRelayNotice('No active session is bound to this conversation.');
+    return;
+  }
+  killSessionInFlight = true;
+  setSummaryModalLoading(true);
+  try {
+    const result = await killSessionWorker(info.sdkSessionId, {
+      conversationId: info.conversationId,
+      title: info.title,
+    });
+    closeSummaryModal();
+    if (!result?.ok) {
+      alert('Failed to kill session');
+      return;
+    }
+    const statusText = result.processStatus === 'killed'
+      ? 'Session killed.'
+      : 'Session state cleared; no live worker process was found.';
+    showTransientRelayNotice(statusText);
+    await menuDeps.refreshSessionWorkerStatus().catch(() => {});
+  } finally {
+    killSessionInFlight = false;
+    setSummaryModalLoading(false);
+  }
+}
+
+export function openRestartRelayConfirmation() {
+  openSummaryModal({
+    title: 'Restart web relay',
+    subtitle: 'Queues restart via /api/relay/shutdown',
+    kind: 'restart-relay',
+    bodyHtml: `
+      <p>Queue a manual relay restart now?</p>
+      <p>The restart waits until the current turn is idle, so it does not interrupt an in-flight turn immediately.</p>
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn" type="button" onclick="confirmRestartWebRelay()">🌄 Restart web relay</button>
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
+      </div>
+    `,
+  });
+}
+
+export function openEmptyQueueConfirmation() {
+  menuDeps.lockChatActionsMenuShield(350);
+  menuDeps.closeChatActionsMenu();
+  openSummaryModal({
+    title: 'Empty queue',
+    subtitle: 'Calls localhost /api/queue/empty',
+    kind: 'empty-queue',
+    bodyHtml: `
+      <p>Drop all queue rows in pending, processing, and parked states?</p>
+      <p>This is a local maintenance action and cannot be undone.</p>
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn danger-btn" type="button" onclick="confirmEmptyQueue()">🚮 Empty queue</button>
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
+      </div>
+    `,
+  });
+}
+
+export function openSuspendHostConfirmation() {
+  if (!isSuspendHostActionVisible()) return;
+  menuDeps.lockChatActionsMenuShield(350);
+  menuDeps.closeChatActionsMenu();
+  openSummaryModal({
+    title: 'Suspend host',
+    subtitle: 'Requests suspend-to-RAM',
+    kind: 'suspend-host',
+    bodyHtml: `
+      <p>Put this PC to sleep now?</p>
+      <p>This requests suspend-to-RAM immediately.</p>
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn" type="button" onclick="confirmSuspendHost()">💤 Suspend host</button>
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
+      </div>
+    `,
+  });
+  window.setTimeout(() => {
+    const modal = document.getElementById('summary-modal');
+    const classVisible = !!modal?.classList?.contains('visible');
+    const ariaVisible = String(modal?.getAttribute('aria-hidden') || 'true') === 'false';
+    const displayVisible = modal ? window.getComputedStyle(modal).display !== 'none' : false;
+    if (classVisible && ariaVisible && displayVisible) return;
+    const confirmed = window.confirm('Put this PC to sleep now?\n\nThis requests suspend-to-RAM.');
+    if (!confirmed) return;
+    confirmSuspendHost().catch(() => {});
+  }, 90);
+}
+
+export async function confirmSuspendHost() {
+  if (!isSuspendHostActionVisible()) return;
+  if (suspendHostInFlight) return;
+  suspendHostInFlight = true;
+  setSummaryModalLoading(true);
+  try {
+    const result = await requestHostSuspend({
+      reason: 'manual-suspend',
+      requestedBy: 'localhost-api',
+    });
+    closeSummaryModal();
+    if (!result?.ok) {
+      alert('Failed to suspend host');
+      return;
+    }
+  } finally {
+    suspendHostInFlight = false;
+    setSummaryModalLoading(false);
+  }
+}
+
+export async function confirmEmptyQueue() {
+  if (emptyQueueInFlight) return;
+  emptyQueueInFlight = true;
+  setSummaryModalLoading(true);
+  try {
+    const result = await requestQueueEmpty({
+      reason: 'manual-empty-queue',
+      requestedBy: 'localhost-api',
+    });
+    closeSummaryModal();
+    if (!result?.ok) {
+      alert('Failed to empty queue');
+      return;
+    }
+    const droppedCount = Number(result.droppedCount || 0);
+    if (droppedCount <= 0) {
+      showTransientRelayNotice('Queue is already empty.');
+    } else {
+      showTransientRelayNotice(`Queue emptied: dropped ${droppedCount} row${droppedCount === 1 ? '' : 's'}.`, 6000);
+    }
+    const status = await refreshWorkspaceRootHints();
+    menuDeps.syncQueueStatusMenuEntry(status);
+  } finally {
+    emptyQueueInFlight = false;
+    setSummaryModalLoading(false);
+  }
+}
+
+export async function confirmRestartWebRelay() {
+  if (restartRelayInFlight) return;
+  restartRelayInFlight = true;
+  setSummaryModalLoading(true);
+  try {
+    const result = await requestRelayRestart({
+      reason: 'manual-restart',
+      requestedBy: 'localhost-api',
+      restart: true,
+    });
+    closeSummaryModal();
+    // Restart can close the connection before the browser receives JSON.
+    if (!result) {
+      showTransientRelayNotice('Relay restart requested. Connection may briefly drop while it restarts.', 7000);
+      return;
+    }
+    if (!result.ok) {
+      alert('Failed to queue relay restart');
+      return;
+    }
+    if (result.accepted === false) {
+      showTransientRelayNotice('Relay is already shutting down/restarting.', 7000);
+      return;
+    }
+    const queue = result.queue || {};
+    showTransientRelayNotice(
+      `Relay restart queued (pending=${Number(queue.pendingCount || 0)}, processing=${Number(queue.processingCount || 0)}).`,
+      7000,
+    );
+  } finally {
+    restartRelayInFlight = false;
+    setSummaryModalLoading(false);
+  }
+}
+
+export function initActionConfirmations({
+  lockChatActionsMenuShield,
+  closeChatActionsMenu,
+  syncQueueStatusMenuEntry,
+  refreshSessionWorkerStatus,
+  exposeOnWindow = true,
+} = {}) {
+  menuDeps = {
+    lockChatActionsMenuShield: typeof lockChatActionsMenuShield === 'function' ? lockChatActionsMenuShield : menuDeps.lockChatActionsMenuShield,
+    closeChatActionsMenu: typeof closeChatActionsMenu === 'function' ? closeChatActionsMenu : menuDeps.closeChatActionsMenu,
+    syncQueueStatusMenuEntry: typeof syncQueueStatusMenuEntry === 'function' ? syncQueueStatusMenuEntry : menuDeps.syncQueueStatusMenuEntry,
+    refreshSessionWorkerStatus: typeof refreshSessionWorkerStatus === 'function' ? refreshSessionWorkerStatus : menuDeps.refreshSessionWorkerStatus,
+  };
+  if (!exposeOnWindow) return;
+  window.openKillSessionConfirmation = openKillSessionConfirmation;
+  window.openRestartRelayConfirmation = openRestartRelayConfirmation;
+  window.openEmptyQueueConfirmation = openEmptyQueueConfirmation;
+  window.openSuspendHostConfirmation = openSuspendHostConfirmation;
+  window.confirmKillCurrentSession = confirmKillCurrentSession;
+  window.confirmRestartWebRelay = confirmRestartWebRelay;
+  window.confirmSuspendHost = confirmSuspendHost;
+  window.confirmEmptyQueue = confirmEmptyQueue;
+}

package/server/public/app/activity-replay-state.mjs

@@ -0,0 +1,149 @@
+const DEFAULT_ACTIVITY_LIMIT = 24;
+
+export function normalizeRelayActivityEntry(item) {
+  if (item && typeof item === 'object' && !Array.isArray(item)) {
+    const text = String(item.text || '').trim();
+    const subagentRunId = item.subagentRunId ? String(item.subagentRunId).trim() : null;
+    if (!text) return null;
+    const metadata = (item.metadata && typeof item.metadata === 'object' && !Array.isArray(item.metadata))
+      ? item.metadata
+      : null;
+    return { text, subagentRunId, metadata };
+  }
+  const text = String(item || '').trim();
+  if (!text) return null;
+  return { text, subagentRunId: null, metadata: null };
+}
+
+// A compaction boundary is published as an ordinary activity row carrying
+// structured metadata. The transcript promotes it to a full-width break row
+// (and drops it from the bubble's tool-activity list), so both sides ask here.
+export function isCompactBoundaryActivityEntry(item) {
+  return normalizeRelayActivityEntry(item)?.metadata?.kind === 'compact_boundary';
+}
+
+function toTokenCount(value) {
+  // `Number(null)` is 0, not NaN: without this an omitted post_tokens (every
+  // real auto-compaction) would read as a compaction down to zero tokens.
+  if (value === null || value === undefined || value === '') return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : null;
+}
+
+// One message carries at most one break row, so when a turn compacted more
+// than once only the LAST boundary is promoted. This returns that entry by
+// identity, so the render path can keep the others visible as prose instead
+// of dropping them (they would otherwise vanish from the transcript).
+export function promotedCompactBoundaryEntry(items) {
+  const list = Array.isArray(items) ? items : [];
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    if (isCompactBoundaryActivityEntry(list[index])) return list[index];
+  }
+  return null;
+}
+
+// The last compaction recorded against one message's activities, as
+// { preTokens, postTokens } (either may be null when the SDK omitted it).
+export function compactBoundaryFromActivities(items) {
+  const promoted = promotedCompactBoundaryEntry(items);
+  if (!promoted) return null;
+  const metadata = normalizeRelayActivityEntry(promoted).metadata;
+  return {
+    preTokens: toTokenCount(metadata.preTokens),
+    postTokens: toTokenCount(metadata.postTokens),
+  };
+}
+
+// Head-cap that never drops structured rows. Activity lists are capped from
+// the front (the start of a turn is the interesting part), but a
+// metadata-bearing row carries transcript structure rather than prose, and a
+// long agentic turn can push its compaction boundary past the cap — losing
+// the break row entirely, with no prose fallback since the bubble filters
+// compact entries out. Keep every structured row, spend the rest of the
+// budget on the leading prose rows, preserve the original order.
+export function capRelayActivityEntries(items, limit = DEFAULT_ACTIVITY_LIMIT) {
+  const list = Array.isArray(items) ? items : [];
+  const max = Math.max(1, Math.trunc(Number(limit)) || DEFAULT_ACTIVITY_LIMIT);
+  if (list.length <= max) return list.slice();
+  const structuredIndexes = [];
+  for (let index = 0; index < list.length; index += 1) {
+    if (normalizeRelayActivityEntry(list[index])?.metadata) structuredIndexes.push(index);
+  }
+  if (!structuredIndexes.length) return list.slice(0, max);
+  // Safety valve for a pathological turn with more structured rows than the
+  // cap allows: the most recent ones win.
+  const keep = new Set(structuredIndexes.slice(-max));
+  let budget = max - keep.size;
+  const kept = [];
+  for (let index = 0; index < list.length; index += 1) {
+    if (keep.has(index)) {
+      kept.push(list[index]);
+      continue;
+    }
+    if (budget <= 0) continue;
+    budget -= 1;
+    kept.push(list[index]);
+  }
+  return kept;
+}
+
+export function relayActivityEntryText(item) {
+  return normalizeRelayActivityEntry(item)?.text || '';
+}
+
+function normalizeActivityItems(items, limit = DEFAULT_ACTIVITY_LIMIT) {
+  const normalized = Array.isArray(items)
+    ? items.map((item) => normalizeRelayActivityEntry(item)).filter(Boolean)
+    : [];
+  return normalized.slice(-Math.max(1, Number(limit) || DEFAULT_ACTIVITY_LIMIT));
+}
+
+function activityEntryKey(item) {
+  const entry = normalizeRelayActivityEntry(item);
+  if (!entry) return '';
+  return `${entry.subagentRunId || ''}::${entry.text}`;
+}
+
+function isSubsequence(subset, sequence) {
+  if (!subset.length) return true;
+  let cursor = 0;
+  for (const item of sequence) {
+    if (activityEntryKey(item) === activityEntryKey(subset[cursor])) cursor += 1;
+    if (cursor >= subset.length) return true;
+  }
+  return false;
+}
+
+export function mergeRelayActivityTexts(existingItems, incomingItems, limit = DEFAULT_ACTIVITY_LIMIT) {
+  const existing = normalizeActivityItems(existingItems, Number.POSITIVE_INFINITY);
+  const incoming = normalizeActivityItems(incomingItems, Number.POSITIVE_INFINITY);
+  if (!existing.length) return normalizeActivityItems(incoming, limit);
+  if (!incoming.length) return normalizeActivityItems(existing, limit);
+  if (isSubsequence(existing, incoming)) return normalizeActivityItems(incoming, limit);
+  if (isSubsequence(incoming, existing)) return normalizeActivityItems(existing, limit);
+
+  const primary = incoming.length > existing.length ? incoming : existing;
+  const secondary = primary === incoming ? existing : incoming;
+  const merged = primary.slice();
+  const seen = new Set(primary.map((item) => activityEntryKey(item)));
+  for (const item of secondary) {
+    const key = activityEntryKey(item);
+    if (!key || seen.has(key)) continue;
+    merged.push(item);
+    seen.add(key);
+  }
+  return normalizeActivityItems(merged, limit);
+}
+
+export function shouldApplyConversationLoad({
+  requestedConversationId,
+  activeConversationId,
+  capturedVersion,
+  currentVersion,
+} = {}) {
+  const requestedId = String(requestedConversationId || '').trim();
+  const activeId = String(activeConversationId || '').trim();
+  return !!requestedId
+    && requestedId === activeId
+    && Number(capturedVersion) === Number(currentVersion);
+}