@oar-sh/oar 0.9.9 → 0.9.11

package/server/public/app/no-conversation-state.mjs

@@ -0,0 +1,58 @@
+// What the transcript shows while no conversation is open. No DOM here;
+// conversation-view.js draws the result into the `.empty-state` node.
+//
+// Three variants: `setup` when the relay has no provider known to be ready
+// (the fresh-install case: point to Settings → Providers, do not pretend
+// Copilot is set up), `first-chat` when a provider is ready and there are no
+// conversations yet, and `pick` when conversations exist but none is open.
+// A readiness answer that is unknown counts as ready, as everywhere else.
+
+import { isSetupRequired } from './provider-readiness.mjs';
+
+export const SETUP_HEADING = 'Set up a provider';
+export const SETUP_TEXT = 'Turn on Claude, Cursor, OpenAI or Grok in Settings → Providers, or sign in to the Copilot CLI on the relay host.';
+
+const ACTIONS = Object.freeze({
+  openSettings: (primary) => ({ id: 'empty-state-open-settings', action: 'open-settings', label: primary ? 'Open Settings' : 'Settings', primary, link: !primary }),
+  newChat: (primary) => ({ id: 'empty-state-new-chat', action: 'new-chat', label: '+ New chat', primary, link: false }),
+  showConversations: () => ({ id: 'empty-state-show-conversations', action: 'show-conversations', label: 'Show conversations', primary: false, link: false }),
+});
+
+/**
+ * @param {object} input
+ * @param {object|null} [input.readiness] resolveProviderReadiness()'s answer
+ * @param {number} [input.conversationCount] live conversations the client knows
+ * @param {boolean} [input.mobile] the sidebar is an off-canvas drawer
+ * @returns {{ variant: 'setup' | 'first-chat' | 'pick', icon: string, heading: string, text: string, actions: Array<{ id: string, action: string, label: string, primary: boolean, link: boolean }> }}
+ */
+export function resolveNoConversationState({ readiness = null, conversationCount = 0, mobile = false } = {}) {
+  if (isSetupRequired(readiness)) {
+    return {
+      variant: 'setup',
+      icon: '⚙️',
+      heading: SETUP_HEADING,
+      text: SETUP_TEXT,
+      actions: [ACTIONS.openSettings(true), ACTIONS.newChat(false)],
+    };
+  }
+  const count = Math.max(0, Number(conversationCount) || 0);
+  if (count === 0) {
+    return {
+      variant: 'first-chat',
+      icon: '🚀',
+      heading: 'Start your first chat',
+      text: 'Pick a model and a folder, and go.',
+      actions: [ACTIONS.newChat(true), ACTIONS.openSettings(false)],
+    };
+  }
+  const actions = [ACTIONS.newChat(true)];
+  if (mobile) actions.push(ACTIONS.showConversations());
+  actions.push(ACTIONS.openSettings(false));
+  return {
+    variant: 'pick',
+    icon: '💬',
+    heading: 'No conversation open',
+    text: 'Pick one from the list or start a new one.',
+    actions,
+  };
+}

package/server/public/app/preview-cards.mjs

@@ -6,8 +6,9 @@
 // The same row builder serves both surfaces: the composer's background-task
 // panel (this conversation's previews, beside the Bash task running the dev
 // server) and the settings modal's "Live previews" list (every session's).
-// Previews never expire, so the settings list is the one place that can always
-// close a link left behind in a conversation you have moved on from.
+// Previews never expire and survive a relay restart, so the settings list is
+// the one place that can always close a link left behind in a conversation you
+// have moved on from; it shows each preview's age and last use to help.
 
 import { apiFetch } from './api-client.js';
 
@@ -21,10 +22,35 @@ export function subscribePreviews(callback) {
   return () => subscribers.delete(callback);
 }
 
+// Transcript cards on screen, with the snapshot each was built from. A card's
+// open/closed state is read from the registry when it is built, and a page that
+// renders a transcript before the registry arrived (the conversation payload
+// carries it after the messages) would otherwise keep showing a live preview
+// as closed.
+const transcriptCards = new Map();
+
+function refreshTranscriptCards() {
+  for (const [card, snapshot] of [...transcriptCards]) {
+    if (!card.isConnected) {
+      transcriptCards.delete(card);
+      continue;
+    }
+    const liveEntry = previews.find((entry) => entry.token === snapshot.token && !entry.unverified);
+    const shownLive = !card.classList.contains('msg-preview-card-closed');
+    // Rebuilt when it opened or closed, and when its link moved (a changed
+    // public address: the live entry carries the current one).
+    if (!!liveEntry === shownLive && (!liveEntry || card.dataset.previewUrl === (liveEntry.url || snapshot.url))) continue;
+    const next = buildTranscriptPreviewCard(snapshot);
+    transcriptCards.delete(card);
+    if (next) card.replaceWith(next);
+  }
+}
+
 function notify() {
   for (const callback of subscribers) {
     try { callback(previews); } catch {}
   }
+  try { refreshTranscriptCards(); } catch {}
 }
 
 function normalizePreview(entry) {
@@ -40,8 +66,12 @@ function normalizePreview(entry) {
     url: String(entry.url || '').trim(),
     basePath: String(entry.basePath || '').trim(),
     createdAt: Number(entry.createdAt) || null,
+    lastHitAt: Number(entry.lastHitAt) || null,
     // null = not probed yet; the badge stays absent rather than guessing.
     online: entry.online === true ? true : (entry.online === false ? false : null),
+    // Stored, but not served: the relay could not check it after a restart
+    // and tries again. It can be closed like any other.
+    unverified: entry.unverified === true,
   };
 }
 
@@ -110,13 +140,31 @@ async function copyPreviewUrl(url, button) {
   }
 }
 
-function previewDetail(preview, { withConversation = false } = {}) {
+export function formatPreviewAge(timestamp, now = Date.now()) {
+  const at = Number(timestamp);
+  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 previewDetail(preview, { withConversation = false, withAge = false, now = Date.now() } = {}) {
   const parts = [];
   if (preview.targetPort) parts.push(`:${preview.targetPort}`);
-  if (preview.online === false) parts.push('offline — dev server not responding');
+  if (preview.unverified) parts.push('not served — could not be checked after the restart, trying again');
+  else if (preview.online === false) parts.push('offline — dev server not responding');
   if (withConversation && preview.conversationId) {
     parts.push(`session ${preview.conversationId.slice(0, 8)}`);
   }
+  if (withAge) {
+    const published = formatPreviewAge(preview.createdAt, now);
+    if (published) parts.push(`published ${published}`);
+    const opened = formatPreviewAge(preview.lastHitAt, now);
+    parts.push(opened ? `last opened ${opened}` : 'never opened');
+  }
   return parts.join(' · ');
 }
 
@@ -124,7 +172,7 @@ function previewDetail(preview, { withConversation = false } = {}) {
  * One preview row. Built with createElement/textContent throughout: a label is
  * agent-supplied text and must never be able to execute as markup.
  */
-export function buildPreviewRow(preview, { withConversation = false } = {}) {
+export function buildPreviewRow(preview, { withConversation = false, withAge = false, now } = {}) {
   const row = document.createElement('div');
   row.className = 'preview-row';
   row.dataset.token = preview.token;
@@ -145,7 +193,7 @@ export function buildPreviewRow(preview, { withConversation = false } = {}) {
   label.textContent = preview.label;
   main.appendChild(label);
 
-  const detailText = previewDetail(preview, { withConversation });
+  const detailText = previewDetail(preview, { withConversation, withAge, now });
   if (detailText) {
     const detail = document.createElement('span');
     detail.className = 'preview-detail';
@@ -177,25 +225,28 @@ export function buildPreviewRow(preview, { withConversation = false } = {}) {
   actions.className = 'preview-actions';
   side.appendChild(actions);
 
-  const open = document.createElement('a');
-  open.className = 'preview-open';
-  open.href = preview.url;
-  open.target = '_blank';
-  // noopener/noreferrer: the preview is a different origin running app code we
-  // do not control, and it has no business holding a handle on this window.
-  open.rel = 'noopener noreferrer';
-  open.textContent = 'Open';
-  actions.appendChild(open);
-
-  const copy = document.createElement('button');
-  copy.type = 'button';
-  copy.className = 'preview-copy';
-  copy.textContent = 'Copy link';
-  copy.addEventListener('click', (event) => {
-    event.preventDefault();
-    void copyPreviewUrl(preview.url, copy);
-  });
-  actions.appendChild(copy);
+  // An unverified preview answers 404 for now: no link to open or copy.
+  if (!preview.unverified) {
+    const open = document.createElement('a');
+    open.className = 'preview-open';
+    open.href = preview.url;
+    open.target = '_blank';
+    // noopener/noreferrer: the preview is a different origin running app code we
+    // do not control, and it has no business holding a handle on this window.
+    open.rel = 'noopener noreferrer';
+    open.textContent = 'Open';
+    actions.appendChild(open);
+
+    const copy = document.createElement('button');
+    copy.type = 'button';
+    copy.className = 'preview-copy';
+    copy.textContent = 'Copy link';
+    copy.addEventListener('click', (event) => {
+      event.preventDefault();
+      void copyPreviewUrl(preview.url, copy);
+    });
+    actions.appendChild(copy);
+  }
 
   const closing = closesInFlight.has(preview.token);
   const close = document.createElement('button');
@@ -214,17 +265,29 @@ export function buildPreviewRow(preview, { withConversation = false } = {}) {
 
 /**
  * Transcript card for a preview published during a turn. Renders from the
- * persisted snapshot (the registry may be long gone), overlaying live state
- * from the current store: a token still registered gets a working row, a
- * vanished one keeps the label but drops the dead link for a `closed` badge.
+ * persisted snapshot, overlaying live state from the current store: a token
+ * still registered (previews survive a restart) gets a working row, a closed
+ * one keeps the label but drops the dead link for a `closed` badge.
+ *
+ * A public share carries no token or link (the link would open the preview to
+ * every reader of the transcript): its cards come as `{ label, redacted }` and
+ * render as a plain note.
  */
 export function buildTranscriptPreviewCard(snapshot) {
+  if (snapshot && typeof snapshot === 'object' && snapshot.redacted === true) {
+    return buildRedactedPreviewCard(snapshot);
+  }
   const preview = normalizePreview(snapshot);
   if (!preview) return null;
-  const live = previews.some((entry) => entry.token === preview.token);
+  const liveEntry = previews.find((entry) => entry.token === preview.token && !entry.unverified);
+  const live = !!liveEntry;
+  // The snapshot's link was built from the public address at publish time;
+  // the live entry's follows the current settings.
+  const url = liveEntry?.url || preview.url;
 
   const card = document.createElement('div');
   card.className = live ? 'msg-preview-card' : 'msg-preview-card msg-preview-card-closed';
+  if (live) card.dataset.previewUrl = url;
 
   const icon = document.createElement('span');
   icon.className = 'preview-icon';
@@ -236,10 +299,12 @@ export function buildTranscriptPreviewCard(snapshot) {
   label.textContent = preview.label;
   card.appendChild(label);
 
+  transcriptCards.set(card, preview);
+
   if (live) {
     const open = document.createElement('a');
     open.className = 'preview-open';
-    open.href = preview.url;
+    open.href = url;
     open.target = '_blank';
     open.rel = 'noopener noreferrer';
     open.textContent = 'Open';
@@ -251,7 +316,7 @@ export function buildTranscriptPreviewCard(snapshot) {
     copy.textContent = 'Copy link';
     copy.addEventListener('click', (event) => {
       event.preventDefault();
-      void copyPreviewUrl(preview.url, copy);
+      void copyPreviewUrl(url, copy);
     });
     card.appendChild(copy);
   } else {
@@ -263,6 +328,27 @@ export function buildTranscriptPreviewCard(snapshot) {
   return card;
 }
 
+function buildRedactedPreviewCard(snapshot) {
+  const card = document.createElement('div');
+  card.className = 'msg-preview-card msg-preview-card-redacted';
+
+  const icon = document.createElement('span');
+  icon.className = 'preview-icon';
+  icon.textContent = '🌐';
+  card.appendChild(icon);
+
+  const label = document.createElement('span');
+  label.className = 'preview-label';
+  label.textContent = String(snapshot.label || '').trim() || 'Preview';
+  card.appendChild(label);
+
+  const note = document.createElement('span');
+  note.className = 'preview-detail';
+  note.textContent = 'preview link not shared';
+  card.appendChild(note);
+  return card;
+}
+
 export function renderPreviewRowsInto(container, rows, options = {}) {
   if (!container) return 0;
   container.textContent = '';

package/server/public/app/preview-command.mjs

@@ -74,6 +74,10 @@ export async function runPreviewCommand(parsed, { conversationId = '' } = {}) {
       if (!previews.length) return { ok: true, notice: 'No live previews.' };
       const lines = previews.map((entry) => {
         const target = entry.mode === 'static' ? entry.rootDir : `:${entry.targetPort}`;
+        // Stored but not served until the relay could check it: no link.
+        if (entry.unverified === true) {
+          return `${entry.token.slice(0, 8)} · ${entry.label} (${target}) — not served, could not be checked after the restart`;
+        }
         const state = entry.online === false ? ' — offline' : '';
         return `${entry.token.slice(0, 8)} · ${entry.label} (${target})${state} → ${entry.url}`;
       });
@@ -96,7 +100,12 @@ export async function runPreviewCommand(parsed, { conversationId = '' } = {}) {
       // point at the panel where the states are visible instead.
       return { ok: false, notice: 'Preview failed — check the port/path, or whether the preview lane is enabled (Settings → Live previews).' };
     }
-    return { ok: true, notice: `Preview published: ${created.url}` };
+    return {
+      ok: true,
+      notice: created.existing === true
+        ? `Preview already published (same link): ${created.url}`
+        : `Preview published: ${created.url}`,
+    };
   } catch {
     return { ok: false, notice: 'Preview command failed — could not reach the relay.' };
   }

package/server/public/app/provider-readiness.mjs

@@ -0,0 +1,120 @@
+// Which providers are known to be ready to run a chat, from what the client
+// already loads: the provider settings payloads and the model catalog. No DOM.
+//
+// OpenAI, Claude, Claude Cloud, Cursor and Grok say so themselves: their
+// settings carry `enabled`. Copilot has no such flag and the relay never asks
+// whether the Copilot CLI is signed in, so the best signal is indirect: has a
+// real Copilot model list ever reached the catalog? A fresh database is seeded
+// with a curated list under the source `bootstrap-seed`; a server discovery,
+// an extension snapshot or a worker snapshot replaces that source. Until one
+// has, Copilot is `unknown`, never "not ready": the signal can be wrong (a
+// signed-in host whose first discovery timed out), so callers only point to
+// Settings and never block.
+//
+// A payload that failed to load is `null`, and makes the whole answer
+// `known: false`. Callers treat an unknown answer as ready, which is today's
+// behaviour: a network blip must never show the setup wall.
+
+export const SEED_CATALOG_SOURCE = 'bootstrap-seed';
+
+const SETTINGS_PROVIDERS = Object.freeze([
+  ['openai', 'openai'],
+  ['claude', 'claude'],
+  ['claudeCloud', 'claude-cloud'],
+  ['cursor', 'cursor'],
+  ['grok', 'grok'],
+]);
+
+/** Payloads whose absence means "could not be loaded" rather than "not offered". */
+const REQUIRED_INPUTS = Object.freeze(['openai', 'claude', 'cursor', 'grok', 'catalog']);
+
+/**
+ * @param {object} input the settings payloads New Chat loads, plus GET /api/models
+ * @param {object|null} [input.openai]
+ * @param {object|null} [input.claude]
+ * @param {object|null} [input.claudeCloud] null on a relay without Claude Cloud: not offered, not unknown
+ * @param {object|null} [input.cursor]
+ * @param {object|null} [input.grok]
+ * @param {object|null} [input.catalog]
+ * @returns {{ known: boolean, anyReady: boolean, ready: string[], copilot: 'ready' | 'unknown' }}
+ */
+export function resolveProviderReadiness(input = {}) {
+  const payloads = input && typeof input === 'object' ? input : {};
+  const known = REQUIRED_INPUTS.every((key) => payloads[key] && typeof payloads[key] === 'object');
+  const ready = [];
+  for (const [key, providerId] of SETTINGS_PROVIDERS) {
+    if (payloads[key]?.enabled === true) ready.push(providerId);
+  }
+  const source = String(payloads.catalog?.source || '').trim();
+  const copilot = payloads.catalog && typeof payloads.catalog === 'object' && source && source !== SEED_CATALOG_SOURCE
+    ? 'ready'
+    : 'unknown';
+  if (copilot === 'ready') ready.push('github');
+  return { known, anyReady: ready.length > 0, ready, copilot };
+}
+
+/** The one question the empty screen, New Chat and the composer ask. */
+export function isSetupRequired(readiness) {
+  return !!readiness && readiness.known === true && readiness.anyReady !== true;
+}
+
+// ── The client's live copy ────────────────────────────────────────────────
+// Fed from the initial loads, the socket events that follow a Settings save
+// or a catalog change, and New Chat's own fresh loads. Subscribers redraw the
+// empty screen and the composer when the answer changes.
+
+const inputs = {
+  openai: undefined,
+  claude: undefined,
+  claudeCloud: undefined,
+  cursor: undefined,
+  grok: undefined,
+  catalog: undefined,
+};
+let current = resolveProviderReadiness(inputs);
+const listeners = new Set();
+
+function readinessKey(readiness) {
+  return `${readiness.known ? 1 : 0}|${readiness.anyReady ? 1 : 0}|${readiness.ready.join(',')}|${readiness.copilot}`;
+}
+
+/**
+ * Records fresh payloads; `null` for a failed load, `undefined` keys are left
+ * as they were. Listeners run only when the resolved answer changed.
+ */
+export function updateProviderReadinessInputs(partial = {}) {
+  if (!partial || typeof partial !== 'object') return current;
+  for (const key of Object.keys(inputs)) {
+    if (partial[key] !== undefined) inputs[key] = partial[key];
+  }
+  const next = resolveProviderReadiness(inputs);
+  const changed = readinessKey(next) !== readinessKey(current);
+  current = next;
+  if (changed) {
+    for (const listener of Array.from(listeners)) {
+      try { listener(current); } catch {}
+    }
+  }
+  return current;
+}
+
+export function getProviderReadiness() {
+  return current;
+}
+
+export function isProviderSetupRequired() {
+  return isSetupRequired(current);
+}
+
+export function subscribeProviderReadiness(listener) {
+  if (typeof listener !== 'function') return () => {};
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+/** Tests only: back to "nothing loaded yet". */
+export function resetProviderReadinessForTests() {
+  for (const key of Object.keys(inputs)) inputs[key] = undefined;
+  current = resolveProviderReadiness(inputs);
+  listeners.clear();
+}

package/server/public/app/relay-board-view.js

@@ -3,6 +3,7 @@ import {
   currentConvId,
   escHtml,
   relayBoards,
+  scrollBottom,
 } from './store.js';
 import {
   boardBodyShownInReply,
@@ -16,6 +17,7 @@ import {
 } from './api-client.js';
 import { renderMarkdownPreview } from './router.js';
 import { attachCodeCopyButtons } from './code-copy.mjs';
+import { beginOwnSend, followsTranscriptEnd, refreshJumpButton, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
 
 // The conversation whose settled boards (acted on, dismissed) are loaded. They
 // are asked for per conversation: only the pending ones matter everywhere.
@@ -26,7 +28,18 @@ export function upsertRelayBoard(board) {
   if (!board || !board.id) return;
   relayBoards.set(board.id, board);
   window.renderConvList?.();
-  renderRelayBoards();
+  showNewRelayBoards();
+}
+
+// A board that arrives is shown to a reader who is at the end. Anyone further
+// up stays where they are; the jump-to-bottom button says that it waits.
+// "At the end" is read here, once, before the board is on the page: the
+// render itself reads no layout, it also runs inside a rebuild of the
+// transcript, where a read would clamp the scroll position to the few rows
+// that are on the page at that moment.
+function showNewRelayBoards() {
+  const atEnd = followsTranscriptEnd();
+  if (renderRelayBoards() && atEnd) scrollBottom();
 }
 
 export async function loadRelayBoards() {
@@ -40,7 +53,7 @@ export async function loadRelayBoards() {
   }
   for (const board of pending) relayBoards.set(board.id, board);
   window.renderConvList?.();
-  renderRelayBoards();
+  showNewRelayBoards();
 }
 
 async function loadBoardHistory(conversationId) {
@@ -186,7 +199,8 @@ export function renderRelayBoards() {
   // the live bubble into the reply, or one of another conversation.
   el.querySelectorAll('.relay-board-inline').forEach((node) => { if (!placed.has(node)) node.remove(); });
   el.querySelectorAll('.relay-board-container').forEach((node) => { if (!node.querySelector('.relay-board-inline')) node.remove(); });
-  if (added) window.scrollBottom?.();
+  refreshJumpButton();
+  return added;
 }
 
 export async function submitRelayBoardAction(boardId, actionId) {
@@ -196,6 +210,7 @@ export async function submitRelayBoardAction(boardId, actionId) {
   const card = document.querySelector(`.relay-board-inline[data-board-id="${CSS.escape(id)}"]`);
   const controls = card ? card.querySelectorAll('button') : [];
   controls.forEach((control) => { control.disabled = true; });
+  const send = beginOwnSend();
 
   try {
     const r = await submitRelayBoardActionApi(id, nextActionId);
@@ -205,6 +220,7 @@ export async function submitRelayBoardAction(boardId, actionId) {
     relayBoards.set(id, r.board);
     window.renderConvList?.();
     renderRelayBoards();
+    scrollAfterOwnSend(send);
   } catch (error) {
     controls.forEach((control) => { control.disabled = false; });
     alert(error.message || 'Failed to submit board action');