@oar-sh/oar 0.9.0

package/server/public/app/known-cwd-options.mjs

@@ -0,0 +1,41 @@
+// Known-CWD option list shared by the Change CWD modal (cwd-picker.js) and the
+// New Chat modal (journal-view.js). Pure module: callers pass in the store and
+// repo-browser values so the list stays testable without a DOM.
+
+// Mirrors normalizeDriveLetterOnlyPath in server/services/workspace-root-path-policy.mjs.
+// It cannot be imported: only server/public is served to the browser.
+export function normalizeKnownCwdPath(value) {
+  const stripped = String(value || '').trim().replace(/[\\/]+$/, '');
+  // Always restore the trailing backslash for Windows drive roots ("D:" → "D:\").
+  // Without it, sending "D:" to the server causes path.resolve("D:") to return the
+  // server's remembered CWD for drive D, not the drive root.
+  if (/^[A-Za-z]:$/.test(stripped)) return `${stripped}\\`;
+  return stripped;
+}
+
+export function buildKnownCwdOptions({
+  currentSessionCwd = '',
+  workspaceRootPath = '',
+  browserCwd = '',
+  recentRoots = [],
+} = {}) {
+  const options = [];
+  const seen = new Set();
+  const add = (label, value, note = '') => {
+    const pathValue = normalizeKnownCwdPath(value);
+    if (!pathValue) return;
+    const key = pathValue.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    options.push({ label, path: pathValue, note });
+  };
+
+  add('Current session CWD', currentSessionCwd, 'Selected session');
+  add('Relay workspace', workspaceRootPath, 'Relay host cwd');
+  add('Current browser folder', browserCwd, 'From file explorer');
+  const history = Array.isArray(recentRoots) ? recentRoots : [];
+  history.forEach((pathValue, index) => {
+    add(`Recent CWD ${index + 1}`, pathValue, 'Relay history');
+  });
+  return options;
+}

package/server/public/app/launch-cwd-path.mjs

@@ -0,0 +1,23 @@
+// Joining the workspace root with a tree-relative path for launch-CWD use
+// (repo browser → known-CWD lists / CWD pickers). Pure module so the separator
+// inference is unit-testable under plain node.
+
+/**
+ * A root is Windows-style when it starts with a drive letter or already
+ * contains a backslash. Only then is the join done with `\` — a POSIX root
+ * (`/home/...`) keeps `/`, which is what the relay host actually resolves.
+ */
+export function isWindowsStyleRoot(basePath) {
+  const root = String(basePath || '').trim();
+  return /^[A-Za-z]:/.test(root) || root.includes('\\');
+}
+
+export function joinLaunchCwdPath(basePath, relativePath) {
+  const root = String(basePath || '').trim().replace(/[\\/]+$/, '');
+  const relRaw = String(relativePath || '').trim().replace(/^[\\/]+/, '');
+  const windowsStyle = isWindowsStyleRoot(root);
+  const rel = windowsStyle ? relRaw.replace(/\//g, '\\') : relRaw.replace(/\\/g, '/');
+  if (!root) return rel;
+  if (!rel) return root;
+  return `${root}${windowsStyle ? '\\' : '/'}${rel}`;
+}

package/server/public/app/live-message-dedupe.mjs

@@ -0,0 +1,57 @@
+import { stripRelayPromptContext } from './relay-prompt-sanitizer.mjs';
+
+function normalizeText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+function normalizeId(value) {
+  const text = String(value || '').trim();
+  return text || '';
+}
+
+function normalizeRole(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function normalizeTimestampMs(value) {
+  const parsed = Date.parse(String(value || '').trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function buildLiveMessageFingerprint(message = {}) {
+  const sanitizedText = stripRelayPromptContext(message?.text, message?.mode);
+  return {
+    id: normalizeId(message?.id),
+    role: normalizeRole(message?.role),
+    text: normalizeText(sanitizedText),
+    timestampMs: normalizeTimestampMs(message?.timestamp),
+    sourceMessageId: normalizeId(message?.sourceMessageId),
+  };
+}
+
+export function isLikelyLiveDuplicateMessage({
+  incomingMessageId = '',
+  incomingMessage = null,
+  existingMessages = [],
+  timestampWindowMs = 15_000,
+  hasPendingTextMatch = false,
+} = {}) {
+  const incoming = buildLiveMessageFingerprint({
+    ...(incomingMessage && typeof incomingMessage === 'object' ? incomingMessage : {}),
+    id: incomingMessageId || incomingMessage?.id || '',
+  });
+  if (!incoming.role || !incoming.text) return false;
+  if (incoming.role === 'user' && hasPendingTextMatch) return true;
+  const timeWindowMs = Math.max(1_000, Number(timestampWindowMs) || 15_000);
+  for (const candidate of Array.isArray(existingMessages) ? existingMessages : []) {
+    const existing = buildLiveMessageFingerprint(candidate);
+    if (incoming.id && existing.id && incoming.id === existing.id) return true;
+    if (incoming.role !== existing.role || incoming.text !== existing.text) continue;
+    if (incoming.sourceMessageId && existing.sourceMessageId && incoming.sourceMessageId === existing.sourceMessageId) {
+      return true;
+    }
+    if (!incoming.timestampMs || !existing.timestampMs) continue;
+    if (Math.abs(incoming.timestampMs - existing.timestampMs) <= timeWindowMs) return true;
+  }
+  return false;
+}

package/server/public/app/message-search-view.js

@@ -0,0 +1,242 @@
+import { escHtml, IS_SHARED_VIEW } from './store.js';
+import { searchMessages } from './api-client.js';
+
+const SEARCH_PAGE_SIZE = 40;
+const SEARCH_DEBOUNCE_MS = 220;
+
+const searchState = {
+  query: '',
+  results: [],
+  offset: 0,
+  hasMore: false,
+  loading: false,
+  error: '',
+  selectedKey: '',
+  scrollTop: 0,
+  requestSeq: 0,
+  debounceTimer: null,
+};
+
+let handlers = {
+  openConversation: null,
+};
+
+function getSearchElements() {
+  return {
+    modal: document.getElementById('message-search-modal'),
+    input: document.getElementById('message-search-input'),
+    list: document.getElementById('message-search-results'),
+    status: document.getElementById('message-search-status'),
+    closeBtn: document.getElementById('message-search-close'),
+    clearBtn: document.getElementById('message-search-clear'),
+  };
+}
+
+function resultKey(result) {
+  const conversationId = String(result?.conversationId || '').trim();
+  const messageId = String(result?.messageId || '').trim();
+  return `${conversationId}:${messageId}`;
+}
+
+function renderSearchResults() {
+  const { list, status } = getSearchElements();
+  if (!list || !status) return;
+  status.textContent = searchState.error
+    || (searchState.loading ? 'Searching…' : (searchState.results.length ? `${searchState.results.length} result${searchState.results.length === 1 ? '' : 's'}` : 'No results'));
+  if (!searchState.results.length) {
+    list.innerHTML = `<div class="message-search-empty">${escHtml(searchState.query.length < 2 ? 'Type at least 2 characters to search message history.' : (searchState.error || 'No matches found.'))}</div>`;
+    return;
+  }
+  list.innerHTML = searchState.results.map((item) => {
+    const key = resultKey(item);
+    const activeClass = key === searchState.selectedKey ? ' active' : '';
+    const title = String(item.conversationTitle || 'Conversation').trim();
+    const snippet = String(item.snippet || '').trim() || '(no text)';
+    const snippetHtml = escHtml(snippet)
+      .replaceAll('&lt;mark&gt;', '<mark>')
+      .replaceAll('&lt;/mark&gt;', '</mark>');
+    const role = String(item.role || '').trim() || 'message';
+    const when = String(item.timestamp || '').trim() || '';
+    return `
+      <button type="button" class="message-search-result${activeClass}" data-search-key="${escHtml(key)}" data-search-conversation="${escHtml(item.conversationId)}" data-search-message="${escHtml(item.messageId)}">
+        <div class="message-search-result-title">${escHtml(title)}</div>
+        <div class="message-search-result-meta">${escHtml(role)}${when ? ` · ${escHtml(new Date(when).toLocaleString())}` : ''}</div>
+        <div class="message-search-result-snippet">${snippetHtml}</div>
+      </button>
+    `;
+  }).join('');
+  if (searchState.hasMore) {
+    list.insertAdjacentHTML('beforeend', '<div class="message-search-loading-more">Scroll for more…</div>');
+  }
+}
+
+async function runMessageSearch({ reset = false } = {}) {
+  const { input } = getSearchElements();
+  const query = String(input?.value || searchState.query || '').trim();
+  if (reset) {
+    searchState.query = query;
+    searchState.offset = 0;
+    searchState.results = [];
+    searchState.hasMore = false;
+    searchState.error = '';
+    searchState.selectedKey = '';
+    renderSearchResults();
+  }
+  if (query.length < 2) {
+    searchState.loading = false;
+    renderSearchResults();
+    return;
+  }
+  if (searchState.loading) return;
+  searchState.loading = true;
+  renderSearchResults();
+  const reqId = ++searchState.requestSeq;
+  const result = await searchMessages({
+    query,
+    limit: SEARCH_PAGE_SIZE,
+    offset: reset ? 0 : searchState.offset,
+  });
+  if (reqId !== searchState.requestSeq) return;
+  searchState.loading = false;
+  if (!result) {
+    searchState.error = 'Search failed.';
+    renderSearchResults();
+    return;
+  }
+  const incoming = Array.isArray(result.results) ? result.results : [];
+  if (reset) {
+    searchState.results = incoming;
+  } else {
+    const seen = new Set(searchState.results.map((item) => resultKey(item)));
+    for (const row of incoming) {
+      const key = resultKey(row);
+      if (!seen.has(key)) {
+        seen.add(key);
+        searchState.results.push(row);
+      }
+    }
+  }
+  searchState.offset = Number(result?.pageInfo?.nextOffset ?? (searchState.results.length));
+  searchState.hasMore = !!result?.pageInfo?.hasMore;
+  searchState.error = '';
+  renderSearchResults();
+}
+
+function scheduleSearchDebounced() {
+  if (searchState.debounceTimer) {
+    window.clearTimeout(searchState.debounceTimer);
+  }
+  searchState.debounceTimer = window.setTimeout(() => {
+    searchState.debounceTimer = null;
+    void runMessageSearch({ reset: true });
+  }, SEARCH_DEBOUNCE_MS);
+}
+
+function openMessageSearchModal() {
+  if (IS_SHARED_VIEW) return;
+  const { modal, input, list } = getSearchElements();
+  if (!modal || !input || !list) return;
+  modal.classList.add('visible');
+  modal.setAttribute('aria-hidden', 'false');
+  input.value = searchState.query;
+  renderSearchResults();
+  requestAnimationFrame(() => {
+    list.scrollTop = searchState.scrollTop;
+    input.focus();
+    input.setSelectionRange(input.value.length, input.value.length);
+  });
+}
+
+function closeMessageSearchModal() {
+  const { modal, list } = getSearchElements();
+  if (!modal) return;
+  if (list) searchState.scrollTop = list.scrollTop;
+  modal.classList.remove('visible');
+  modal.setAttribute('aria-hidden', 'true');
+}
+
+function clearMessageSearchRuntimeState() {
+  searchState.query = '';
+  searchState.results = [];
+  searchState.offset = 0;
+  searchState.hasMore = false;
+  searchState.loading = false;
+  searchState.error = '';
+  searchState.selectedKey = '';
+  searchState.scrollTop = 0;
+  searchState.requestSeq += 1;
+  if (searchState.debounceTimer) {
+    window.clearTimeout(searchState.debounceTimer);
+    searchState.debounceTimer = null;
+  }
+  closeMessageSearchModal();
+  renderSearchResults();
+}
+
+function bindMessageSearchEvents() {
+  const { modal, input, list, closeBtn, clearBtn } = getSearchElements();
+  if (!modal || !input || !list || !closeBtn || !clearBtn) return;
+  if (modal.dataset.bound === '1') return;
+  modal.dataset.bound = '1';
+
+  closeBtn.addEventListener('click', (event) => {
+    event.preventDefault();
+    closeMessageSearchModal();
+  });
+  clearBtn.addEventListener('click', (event) => {
+    event.preventDefault();
+    clearMessageSearchRuntimeState();
+  });
+  modal.addEventListener('click', (event) => {
+    if (event.target === modal) closeMessageSearchModal();
+  });
+  document.addEventListener('keydown', (event) => {
+    if (event.key !== 'Escape') return;
+    if (!modal.classList.contains('visible')) return;
+    closeMessageSearchModal();
+  });
+  input.addEventListener('input', () => {
+    scheduleSearchDebounced();
+  });
+  input.addEventListener('keydown', (event) => {
+    if (event.key === 'Enter') {
+      event.preventDefault();
+      void runMessageSearch({ reset: true });
+    }
+  });
+  list.addEventListener('scroll', () => {
+    searchState.scrollTop = list.scrollTop;
+    const remaining = list.scrollHeight - list.clientHeight - list.scrollTop;
+    if (remaining <= 120 && searchState.hasMore && !searchState.loading) {
+      void runMessageSearch({ reset: false });
+    }
+  }, { passive: true });
+  list.addEventListener('click', (event) => {
+    const target = event.target instanceof Element ? event.target.closest('[data-search-conversation][data-search-message]') : null;
+    if (!target) return;
+    const conversationId = String(target.getAttribute('data-search-conversation') || '').trim();
+    const messageId = String(target.getAttribute('data-search-message') || '').trim();
+    if (!conversationId || !messageId) return;
+    searchState.selectedKey = String(target.getAttribute('data-search-key') || '').trim();
+    renderSearchResults();
+    closeMessageSearchModal();
+    void handlers.openConversation?.(conversationId, {
+      aroundMessageId: messageId,
+      focusMessageId: messageId,
+    });
+  });
+}
+
+export function initMessageSearchView({ openConversation } = {}) {
+  handlers = {
+    openConversation: typeof openConversation === 'function' ? openConversation : null,
+  };
+  bindMessageSearchEvents();
+  renderSearchResults();
+}
+
+export {
+  openMessageSearchModal,
+  closeMessageSearchModal,
+  clearMessageSearchRuntimeState,
+};

package/server/public/app/model-selector-options.mjs

@@ -0,0 +1,31 @@
+export function normalizeModelSelectorOptions(models = [], {
+  autoValue = 'auto',
+  labelFor = (modelId) => modelId,
+} = {}) {
+  const normalizedAuto = String(autoValue || 'auto').trim() || 'auto';
+  const values = Array.from(new Set(
+    (Array.isArray(models) ? models : [])
+      .map((modelId) => String(modelId || '').trim())
+      .filter(Boolean),
+  )).filter((modelId) => modelId.toLowerCase() !== normalizedAuto.toLowerCase());
+  values.sort((left, right) => {
+    const labelOrder = String(labelFor(left) || left).localeCompare(
+      String(labelFor(right) || right),
+      undefined,
+      { sensitivity: 'base', numeric: true },
+    );
+    return labelOrder || left.localeCompare(right);
+  });
+  return [
+    { value: normalizedAuto, label: String(labelFor(normalizedAuto) || normalizedAuto) },
+    ...values.map((value) => ({ value, label: String(labelFor(value) || value) })),
+  ];
+}
+
+export function modelSelectorOptionsEqual(currentOptions = [], nextOptions = []) {
+  return currentOptions.length === nextOptions.length
+    && nextOptions.every((option, index) => (
+      currentOptions[index]?.value === option.value
+      && currentOptions[index]?.label === option.label
+    ));
+}

package/server/public/app/model-vision-support.mjs

@@ -0,0 +1,56 @@
+// Advisory vision-capability heuristic for the composer.
+//
+// The browser only ever receives a list of model ID strings; the relay's model
+// catalog does not carry `capabilities.supports.vision`. Until that metadata is
+// plumbed through we cannot be authoritative, so this module is deliberately
+// conservative: it warns only about models known to be text-only and stays
+// silent whenever it does not recognise the id. The warning never blocks send.
+
+const KNOWN_TEXT_ONLY_PATTERNS = [
+  /^o1-mini/,
+  /^o1-preview/,
+  /^text-embedding/,
+  /^codestral/,
+  /^code-davinci/,
+  /^text-davinci/,
+  /-instruct-text$/,
+  /^deepseek-coder/,
+  /^qwen[\w.-]*-coder/,
+];
+
+export function normalizeModelId(modelId) {
+  return String(modelId || '').trim().toLowerCase();
+}
+
+/**
+ * Returns false only for models we positively recognise as text-only.
+ * Unknown ids are assumed vision-capable so the composer stays quiet rather
+ * than crying wolf on every model it has not heard of.
+ */
+export function modelLikelySupportsVision(modelId) {
+  const normalized = normalizeModelId(modelId);
+  if (!normalized) return true;
+  return !KNOWN_TEXT_ONLY_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+export function countImageAttachments(attachments = []) {
+  const list = Array.isArray(attachments) ? attachments : [];
+  return list.filter((attachment) => {
+    if (!attachment) return false;
+    if (typeof attachment.isImage === 'boolean') return attachment.isImage;
+    return String(attachment.type || '').toLowerCase().startsWith('image/');
+  }).length;
+}
+
+export function shouldWarnAboutImageAttachments(modelId, attachments = []) {
+  if (!countImageAttachments(attachments)) return false;
+  return !modelLikelySupportsVision(modelId);
+}
+
+export function imageAttachmentWarningText(modelId, attachments = []) {
+  if (!shouldWarnAboutImageAttachments(modelId, attachments)) return '';
+  const count = countImageAttachments(attachments);
+  const noun = count === 1 ? 'image' : 'images';
+  const label = String(modelId || '').trim() || 'the selected model';
+  return `${label} may not read ${noun} — the ${noun} will be sent as a file reference instead.`;
+}

package/server/public/app/new-conversation-model-choice.mjs

@@ -0,0 +1,67 @@
+export function shouldPromptForNewConversationModel({ provider = '' } = {}) {
+  const normalizedProvider = String(provider || '').trim().toLowerCase();
+  return normalizedProvider === 'openai'
+    || normalizedProvider === 'openai-byok'
+    || normalizedProvider === 'openai-image'
+    || normalizedProvider === 'openai-image-byok';
+}
+
+export function buildNewConversationModelChoices(options = []) {
+  const seen = new Set();
+  const choices = [];
+  for (const option of Array.isArray(options) ? options : []) {
+    const value = String(option?.value || '').trim();
+    if (!value || option?.runtimeModelLock === true || seen.has(value)) continue;
+    seen.add(value);
+    choices.push({
+      value,
+      label: String(option?.label || value),
+    });
+  }
+  return choices;
+}
+
+function normalizeProviderKey(provider = '') {
+  const key = String(provider || '').trim().toLowerCase();
+  if (key === 'openai-byok') return 'openai';
+  if (key === 'github-copilot') return 'github';
+  return key;
+}
+
+export function normalizeReasoningEfforts(efforts = []) {
+  const out = [];
+  const seen = new Set();
+  for (const effort of Array.isArray(efforts) ? efforts : []) {
+    const value = String(effort || '').trim().toLowerCase();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+
+export function reasoningChoicesForProviderModel(catalog = {}, {
+  provider = '',
+  modelId = '',
+} = {}) {
+  const normalizedModelId = String(modelId || '').trim().toLowerCase();
+  if (!normalizedModelId) return [];
+  const providerKey = normalizeProviderKey(provider);
+  const providerOptions = catalog?.reasoningByProvider?.[providerKey]?.[normalizedModelId];
+  if (Array.isArray(providerOptions) && providerOptions.length > 0) {
+    return normalizeReasoningEfforts(providerOptions);
+  }
+  return normalizeReasoningEfforts(catalog?.reasoningByModel?.[normalizedModelId] || []);
+}
+
+export function resolvePreferredReasoningEffort(efforts = [], preferredValues = []) {
+  const normalizedEfforts = normalizeReasoningEfforts(efforts);
+  if (!normalizedEfforts.length) return '';
+  const candidates = Array.isArray(preferredValues) ? preferredValues : [preferredValues];
+  for (const candidate of candidates) {
+    const value = String(candidate || '').trim().toLowerCase();
+    if (value && normalizedEfforts.includes(value)) return value;
+  }
+  const firstNonNone = normalizedEfforts.find((value) => value !== 'none');
+  return firstNonNone || normalizedEfforts[0];
+}