@oar-sh/oar 0.9.0

package/server/public/app/stream-state.mjs

@@ -0,0 +1,73 @@
+export function normalizeStreamSeq(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return null;
+  return Math.max(0, Math.trunc(numeric));
+}
+
+export function deriveLatestInFlightStreamEvent(inFlight) {
+  const rows = Array.isArray(inFlight?.streamEvents) ? inFlight.streamEvents : [];
+  if (!rows.length) return null;
+  let latest = null;
+  for (const row of rows) {
+    const seq = normalizeStreamSeq(row?.seq);
+    if (seq === null) continue;
+    if (!latest || seq > latest.seq) {
+      latest = {
+        seq,
+        text: String(row?.text || ''),
+        done: !!row?.done,
+      };
+    }
+  }
+  return latest;
+}
+
+/**
+ * Latest persisted stream row per thread, so a reload can repaint the main
+ * reply preview and every subagent bubble. `deriveLatestInFlightStreamEvent`
+ * collapses all threads into one row, which is right for the shared seq/done
+ * state machine but loses the per-thread text.
+ *
+ * Returns `{ main, bySubagentRunId }` — `main` is null when the turn has only
+ * produced subagent output so far.
+ */
+export function deriveInFlightStreamTextByThread(inFlight) {
+  const rows = Array.isArray(inFlight?.streamEvents) ? inFlight.streamEvents : [];
+  let main = null;
+  const bySubagentRunId = new Map();
+  for (const row of rows) {
+    const seq = normalizeStreamSeq(row?.seq);
+    if (seq === null) continue;
+    const entry = { seq, text: String(row?.text || ''), done: !!row?.done };
+    const subagentRunId = String(row?.subagentRunId || '').trim();
+    if (!subagentRunId) {
+      if (!main || seq > main.seq) main = entry;
+      continue;
+    }
+    const previous = bySubagentRunId.get(subagentRunId);
+    if (!previous || seq > previous.seq) bySubagentRunId.set(subagentRunId, entry);
+  }
+  return { main, bySubagentRunId };
+}
+
+export function computeNextRelayStreamState(previousState = null, incoming = null) {
+  const previous = previousState && typeof previousState === 'object'
+    ? previousState
+    : { seq: 0, done: false };
+  const nextSeq = normalizeStreamSeq(incoming?.seq);
+  const incomingDone = !!incoming?.done;
+  if (nextSeq !== null && nextSeq <= Number(previous.seq || 0)) {
+    return { accept: false, state: previous };
+  }
+  if (previous.done && !incomingDone) {
+    return { accept: false, state: previous };
+  }
+  return {
+    accept: true,
+    state: {
+      seq: nextSeq === null ? Number(previous.seq || 0) : nextSeq,
+      done: previous.done || incomingDone,
+    },
+  };
+}

package/server/public/app/streaming-dom-patch.mjs

@@ -0,0 +1,23 @@
+// Pure planning helpers for incremental streaming renders: streamed markdown
+// and activity logs grow at the tail, so a render only needs to touch nodes
+// from the first divergence onward instead of rebuilding the whole container.
+
+export function computeStablePrefixLength(previous = [], next = []) {
+  const limit = Math.min(previous.length, next.length);
+  let index = 0;
+  while (index < limit && previous[index] === next[index]) index += 1;
+  return index;
+}
+
+/**
+ * Plan how to bring a rendered list of rows up to date. Returns `reset: true`
+ * (rebuild everything) when existing rows diverge from the expected list;
+ * otherwise only the missing tail is appended.
+ */
+export function planListPatch(currentTexts = [], expectedTexts = []) {
+  const stable = computeStablePrefixLength(currentTexts, expectedTexts);
+  if (stable < currentTexts.length) {
+    return { reset: true, appends: [...expectedTexts] };
+  }
+  return { reset: false, appends: expectedTexts.slice(currentTexts.length) };
+}

package/server/public/app/sync-outbox.mjs

@@ -0,0 +1,208 @@
+import { BASE, CLIENT_ID, authHeaders, conversations } from './store.js';
+
+// Durable outbox for Background Sync: message sends, ask_user answers, and
+// draft flushes that failed (or might die mid-flight on pagehide) are queued
+// in IndexedDB and replayed by the service worker's `sync` handler. The store
+// layout here must match the reader in sw.js, which cannot import modules.
+
+const DB_NAME = 'copilot-remote-sync';
+const DB_VERSION = 1;
+const STORE_NAME = 'outbox';
+export const OUTBOX_SYNC_TAG = 'copilot-outbox';
+const MAX_REPLAY_ATTEMPTS = 10;
+
+function openOutboxDb() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { autoIncrement: true });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error || new Error('IndexedDB unavailable'));
+  });
+}
+
+function requestAsPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error || new Error('IndexedDB request failed'));
+  });
+}
+
+/**
+ * @param {{ kind: string, path: string, method?: string, body: string }} entry
+ *   `path` is BASE-relative (e.g. "/api/message"); `body` is a JSON string.
+ */
+export async function enqueueOutboxRequest(entry) {
+  if (!('indexedDB' in window)) return false;
+  try {
+    const db = await openOutboxDb();
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    tx.objectStore(STORE_NAME).add({
+      kind: String(entry?.kind || 'request'),
+      path: String(entry?.path || ''),
+      method: String(entry?.method || 'POST'),
+      body: String(entry?.body || ''),
+      createdAt: Date.now(),
+      attempts: 0,
+    });
+    await new Promise((resolve, reject) => {
+      tx.oncomplete = resolve;
+      tx.onerror = () => reject(tx.error || new Error('IndexedDB write failed'));
+      tx.onabort = () => reject(tx.error || new Error('IndexedDB write aborted'));
+    });
+    db.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Ask the service worker to replay the outbox when connectivity returns.
+ * Returns false when Background Sync is unavailable (non-Chromium); the caller
+ * falls back to page-side replay via initOutboxFallbackReplay().
+ */
+export async function registerOutboxSync() {
+  try {
+    const registration = await navigator.serviceWorker?.getRegistration?.();
+    if (registration && 'sync' in registration) {
+      await registration.sync.register(OUTBOX_SYNC_TAG);
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
+async function readOutboxEntries(db) {
+  const tx = db.transaction(STORE_NAME, 'readonly');
+  const store = tx.objectStore(STORE_NAME);
+  const [keys, values] = await Promise.all([
+    requestAsPromise(store.getAllKeys()),
+    requestAsPromise(store.getAll()),
+  ]);
+  return keys.map((key, index) => ({ key, value: values[index] }));
+}
+
+async function deleteOutboxEntry(db, key) {
+  const tx = db.transaction(STORE_NAME, 'readwrite');
+  tx.objectStore(STORE_NAME).delete(key);
+  return new Promise((resolve) => {
+    tx.oncomplete = resolve;
+    tx.onerror = resolve;
+    tx.onabort = resolve;
+  });
+}
+
+async function updateOutboxEntry(db, key, value) {
+  const tx = db.transaction(STORE_NAME, 'readwrite');
+  tx.objectStore(STORE_NAME).put(value, key);
+  return new Promise((resolve) => {
+    tx.oncomplete = resolve;
+    tx.onerror = resolve;
+    tx.onabort = resolve;
+  });
+}
+
+// A 4xx (other than timeout/rate-limit) means the server made a decision about
+// this exact request — including 409 DUPLICATE_MESSAGE_ID for a send that
+// actually landed on a previous ambiguous attempt — so the entry is finished.
+function isFinalResponse(response) {
+  if (!response) return false;
+  if (response.ok) return true;
+  return response.status >= 400 && response.status < 500
+    && response.status !== 408 && response.status !== 429;
+}
+
+/**
+ * Page-side replay for browsers without Background Sync. Replays in insertion
+ * order; stops at the first retryable failure so ordering is preserved.
+ */
+export async function replayOutboxFromPage() {
+  if (!('indexedDB' in window)) return { replayed: 0 };
+  let db = null;
+  let replayed = 0;
+  try {
+    db = await openOutboxDb();
+    const entries = await readOutboxEntries(db);
+    for (const { key, value } of entries) {
+      let response = null;
+      try {
+        response = await fetch(`${BASE}${value.path}`, {
+          method: value.method || 'POST',
+          headers: { 'Content-Type': 'application/json', ...authHeaders() },
+          body: value.body,
+        });
+      } catch {
+        response = null;
+      }
+      if (isFinalResponse(response)) {
+        await deleteOutboxEntry(db, key);
+        replayed += 1;
+        continue;
+      }
+      const attempts = Number(value.attempts || 0) + 1;
+      if (attempts >= MAX_REPLAY_ATTEMPTS) {
+        await deleteOutboxEntry(db, key);
+      } else {
+        await updateOutboxEntry(db, key, { ...value, attempts });
+      }
+      break;
+    }
+  } catch {} finally {
+    try { db?.close(); } catch {}
+  }
+  return { replayed };
+}
+
+let fallbackReplayBound = false;
+
+/**
+ * When Background Sync is unsupported, replay the queue from the page on load
+ * and whenever connectivity returns.
+ */
+export async function initOutboxFallbackReplay() {
+  try {
+    const registration = await navigator.serviceWorker?.getRegistration?.();
+    if (registration && 'sync' in registration) return;
+  } catch {}
+  if (fallbackReplayBound) return;
+  fallbackReplayBound = true;
+  void replayOutboxFromPage();
+  window.addEventListener('online', () => {
+    void replayOutboxFromPage();
+  });
+}
+
+/**
+ * Best-effort durable draft flush for pagehide: the direct PATCH the page
+ * fires can be killed mid-flight, so the same update is queued for the
+ * service worker. If the direct write wins, the replay's baseDraftUpdatedAt
+ * is stale and the server rejects it with a version conflict, which the
+ * replay treats as final. Only queues when the draft differs from the last
+ * persisted state.
+ */
+export async function enqueueDraftFlushForBackgroundSync(conversationId) {
+  const id = String(conversationId || '').trim();
+  if (!id) return false;
+  const conversation = conversations[id];
+  if (!conversation) return false;
+  const input = document.getElementById('msg-input');
+  const draftText = String(input ? input.value : (conversation.draftText || ''));
+  if (draftText === String(conversation.draftText || '')) return false;
+  const queued = await enqueueOutboxRequest({
+    kind: 'draft-flush',
+    path: `/api/conversation/${encodeURIComponent(id)}/draft`,
+    method: 'PATCH',
+    body: JSON.stringify({
+      draftText,
+      clientId: CLIENT_ID,
+      baseDraftUpdatedAt: conversation.draftUpdatedAt || null,
+    }),
+  });
+  if (queued) void registerOutboxSync();
+  return queued;
+}

package/server/public/app/tap-actions.js

@@ -0,0 +1,62 @@
+// Shared touch/click activation helpers for the header menus (chat actions menu,
+// sidebar toggle, theme button, tmux inspector menu).
+//
+// These activate on `pointerup` and then swallow the follow-up synthetic click on
+// the *same* element. That is only safe when the surrounding menu is an overlay
+// that does not reflow siblings AND the caller arms a full-screen shield (see
+// lockChatActionsMenuShield in bootstrap.js) so the delayed compatibility click
+// cannot land on whatever is underneath.
+//
+// New code should prefer plain `click` activation instead — see cwd-picker.js,
+// which does all of its state changes in click/keydown handlers so no synthetic
+// click can ever leak to another element.
+
+export function bindTapAction(element, handler) {
+  if (!element || element.dataset.tapBound === '1') return;
+  element.dataset.tapBound = '1';
+  let suppressClickUntil = 0;
+  const markSuppressed = (ms = 450) => {
+    suppressClickUntil = Date.now() + Math.max(200, Number(ms) || 450);
+  };
+  element.addEventListener('pointerup', (event) => {
+    if (event.pointerType === 'mouse' && event.button !== 0) return;
+    event.preventDefault();
+    event.stopPropagation();
+    markSuppressed();
+    handler(event);
+  });
+  element.addEventListener('click', (event) => {
+    if (Date.now() < suppressClickUntil) {
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+    handler(event);
+  });
+}
+
+export function bindMenuAction(element, handler) {
+  if (!element || element.dataset.menuTapBound === '1') return;
+  element.dataset.menuTapBound = '1';
+  let suppressClickUntil = 0;
+  const markSuppressed = (ms = 450) => {
+    suppressClickUntil = Date.now() + Math.max(200, Number(ms) || 450);
+  };
+  element.addEventListener('pointerup', (event) => {
+    if (event.pointerType === 'mouse' && event.button !== 0) return;
+    event.preventDefault();
+    event.stopPropagation();
+    event.stopImmediatePropagation();
+    markSuppressed();
+    handler(event);
+  }, true);
+  element.addEventListener('click', (event) => {
+    if (Date.now() < suppressClickUntil) {
+      event.preventDefault();
+      event.stopPropagation();
+      event.stopImmediatePropagation();
+      return;
+    }
+    handler(event);
+  }, true);
+}

package/server/public/app/thread-order.mjs

@@ -0,0 +1,54 @@
+function normalizeId(value) {
+  const text = String(value || '').trim();
+  return text || '';
+}
+
+export function getMessageThreadAnchor(message, messageById = null) {
+  const sourceId = normalizeId(message?.sourceMessageId || message?.parentMessageId || message?.threadId);
+  if (sourceId && messageById instanceof Map && messageById.has(sourceId)) return sourceId;
+  return normalizeId(message?.id);
+}
+
+export function sortConversationMessages(messages) {
+  const list = Array.isArray(messages) ? messages.filter((message) => !!message) : [];
+  const messageById = new Map(
+    list
+      .map((message) => [normalizeId(message?.id), message])
+      .filter(([id]) => !!id),
+  );
+
+  const anchorTimestampCache = new Map();
+  function anchorTimestamp(message) {
+    const anchorId = getMessageThreadAnchor(message, messageById);
+    if (anchorTimestampCache.has(anchorId)) return anchorTimestampCache.get(anchorId);
+    const anchorMessage = messageById.get(anchorId) || message;
+    const ts = Date.parse(anchorMessage?.timestamp || message?.timestamp || 0);
+    const value = Number.isFinite(ts) ? ts : 0;
+    anchorTimestampCache.set(anchorId, value);
+    return value;
+  }
+
+  function roleRank(message) {
+    return String(message?.role || '').trim().toLowerCase() === 'user' ? 0 : 1;
+  }
+
+  return list.slice().sort((a, b) => {
+    const aAnchorTs = anchorTimestamp(a);
+    const bAnchorTs = anchorTimestamp(b);
+    if (aAnchorTs !== bAnchorTs) return aAnchorTs - bAnchorTs;
+
+    const aAnchorId = getMessageThreadAnchor(a, messageById);
+    const bAnchorId = getMessageThreadAnchor(b, messageById);
+    if (aAnchorId !== bAnchorId) return aAnchorId.localeCompare(bAnchorId);
+
+    const aRoleRank = roleRank(a);
+    const bRoleRank = roleRank(b);
+    if (aRoleRank !== bRoleRank) return aRoleRank - bRoleRank;
+
+    const aTs = Date.parse(a?.timestamp || 0);
+    const bTs = Date.parse(b?.timestamp || 0);
+    if (Number.isFinite(aTs) && Number.isFinite(bTs) && aTs !== bTs) return aTs - bTs;
+
+    return normalizeId(a?.id).localeCompare(normalizeId(b?.id));
+  });
+}