@oar-sh/oar 0.9.6 → 0.9.8

package/server/public/app/api-client.js

@@ -46,7 +46,9 @@ export function areNetworkRequestsEnabled() {
 }
 
 export async function apiFetch(url, opts = {}) {
-  if (!networkRequestsEnabled) return null;
+  // A keepalive request is a page's last word; it goes out even when the
+  // page's regular network work is already suspended.
+  if (!networkRequestsEnabled && !opts.keepalive) return null;
   try {
     const response = await fetch(`${BASE}${url}`, {
       signal: requestTimeoutSignal(),
@@ -273,11 +275,13 @@ export async function updateClaudeSettings({
   enabled = undefined,
   model = undefined,
   enabledModels = undefined,
+  attributionMode = undefined,
 } = {}) {
   const payload = {};
   if (typeof enabled === 'boolean') payload.enabled = enabled;
   if (typeof model === 'string' && model.trim()) payload.model = model.trim();
   if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+  if (typeof attributionMode === 'string' && attributionMode.trim()) payload.attributionMode = attributionMode.trim();
   return settingsRequest('/api/settings/claude', payload, 'Failed to update Claude settings');
 }
 
@@ -370,6 +374,65 @@ export async function updateGrokSettings({
   return settingsRequest('/api/settings/grok', payload, 'Failed to update Grok settings');
 }
 
+// Claude Cloud (provider `claude-cloud`). A relay without these routes answers
+// 404, and a folder outside the workspace roots is refused: both must read as
+// "nothing to show" (the New Chat option stays hidden, the fields stay empty),
+// so these reads skip apiFetch's error logging.
+async function quietGet(path) {
+  if (!networkRequestsEnabled) return null;
+  try {
+    const response = await fetch(`${BASE}${path}`, {
+      signal: requestTimeoutSignal(),
+      headers: { 'Content-Type': 'application/json', ...authHeaders() },
+    });
+    if (!response.ok) return null;
+    noteFetchSuccess();
+    return await response.json().catch(() => null);
+  } catch (error) {
+    noteFetchFailure(path, error);
+    return null;
+  }
+}
+
+export async function loadClaudeCloudSettings() {
+  return quietGet('/api/settings/claude-cloud');
+}
+
+export async function updateClaudeCloudSettings({
+  enabled = undefined,
+  defaultModel = undefined,
+  environmentId = undefined,
+} = {}) {
+  const payload = {};
+  if (typeof enabled === 'boolean') payload.enabled = enabled;
+  if (typeof defaultModel === 'string' && defaultModel.trim()) payload.defaultModel = defaultModel.trim();
+  if (typeof environmentId === 'string' && environmentId.trim()) payload.environmentId = environmentId.trim();
+  return settingsRequest('/api/settings/claude-cloud', payload, 'Failed to update Claude Cloud settings');
+}
+
+// origin + current branch of a folder on the relay host, for the New Chat
+// Repository and Branch fields. null when the relay could not say.
+export async function loadGitRemote(rootPath) {
+  const root = String(rootPath || '').trim();
+  if (!root) return null;
+  return quietGet(`/api/git/remote?root=${encodeURIComponent(root)}`);
+}
+
+// The repositories the Claude GitHub app can reach, plus the ones used in
+// earlier cloud chats here, for the New Chat Repository suggestions. null
+// when the relay could not say (the field is then typed, as before).
+export async function loadClaudeCloudRepos({ refresh = false } = {}) {
+  return quietGet(`/api/claude-cloud/repos${refresh ? '?refresh=1' : ''}`);
+}
+
+// The branches of a GitHub repository as the relay host's git sees them, for
+// the New Chat Branch suggestions. null when the relay could not say.
+export async function loadClaudeCloudBranches(repo) {
+  const text = String(repo || '').trim();
+  if (!text) return null;
+  return quietGet(`/api/claude-cloud/branches?repo=${encodeURIComponent(text)}`);
+}
+
 export async function updateOpenAISettings({
   apiKey = '',
   model = 'gpt-4o',
@@ -542,6 +605,23 @@ export async function updateRemoteRelaySettings(patch = {}) {
   return remoteRelayRequest('/api/settings/remote-relays', { method: 'POST', body });
 }
 
+// ─── Agent sessions (Settings → Relays) ──────────────────────────────────────
+// `{ enabled, maxWaitSeconds, limits, maxActiveSessions }`, with `ok` and
+// `status` as above. A relay without the feature answers 404, which the
+// section reads as "do not show me", so the status has to travel with the
+// answer instead of apiFetch's bare null.
+
+export async function loadAgentSessionsSettings() {
+  return remoteRelayRequest('/api/settings/agent-sessions');
+}
+
+export async function updateAgentSessionsSettings(patch = {}) {
+  const body = {};
+  if (typeof patch.enabled === 'boolean') body.enabled = patch.enabled;
+  if (Number.isFinite(patch.maxWaitSeconds)) body.maxWaitSeconds = patch.maxWaitSeconds;
+  return remoteRelayRequest('/api/settings/agent-sessions', { method: 'POST', body });
+}
+
 export async function loadUpdateState() {
   return apiFetch('/api/update/state');
 }
@@ -607,8 +687,18 @@ export async function relaunchSessionWorkerWithWorkspaceRoot(conversationId, roo
   });
 }
 
-export async function loadUsageSummary() {
-  return apiFetch('/api/usage');
+export async function loadUsageSummary({ providers = null } = {}) {
+  // The conversation the modal was opened from: the Claude Cloud card shows
+  // that conversation's own cost next to the totals. `providers` names the
+  // cards to read live (the rest come from the relay's last live answer);
+  // none means everything live.
+  const conversationId = String(currentConvId || '').trim();
+  const query = new URLSearchParams();
+  if (conversationId) query.set('conversationId', conversationId);
+  const ids = (Array.isArray(providers) ? providers : []).map((id) => String(id || '').trim()).filter(Boolean);
+  if (ids.length) query.set('providers', ids.join(','));
+  const text = query.toString();
+  return apiFetch(text ? `/api/usage?${text}` : '/api/usage');
 }
 
 export async function loadCursorAllowanceSettings() {
@@ -690,8 +780,9 @@ export async function loadConversations(options = {}) {
   if (beforeConversationId) params.set('beforeConversationId', beforeConversationId);
   const beforeUpdatedAt = String(options.beforeUpdatedAt || '').trim();
   if (beforeUpdatedAt) params.set('beforeUpdatedAt', beforeUpdatedAt);
-  const includeArchived = String(options.archived || '').trim().toLowerCase();
-  if (includeArchived === 'true') params.set('archived', 'true');
+  // 'true' lists live and archived chats, 'only' the archived ones.
+  const archivedMode = String(options.archived || '').trim().toLowerCase();
+  if (archivedMode === 'true' || archivedMode === 'only') params.set('archived', archivedMode);
   const query = params.toString();
   return apiFetch(`/api/conversations${query ? `?${query}` : ''}`);
 }
@@ -743,6 +834,39 @@ export async function searchMessages(options = {}) {
 // Raw fetch instead of apiFetch: a refused delete (the conversation is still
 // working, or its session would not stop) must surface the server's reason.
 // The long timeout covers stopping the session and deleting its CLI session.
+// Archive and unarchive answer `{ ok }`, or `{ ok: false, message }` when the
+// relay refuses (a chat still working on a reply is not archived).
+export async function archiveConversation(id) {
+  const convId = String(id || '').trim();
+  if (!convId) return null;
+  return conversationActionRequest(`/api/conversation/${encodeURIComponent(convId)}/archive`);
+}
+
+export async function unarchiveConversation(id) {
+  const convId = String(id || '').trim();
+  if (!convId) return null;
+  return conversationActionRequest(`/api/conversation/${encodeURIComponent(convId)}/unarchive`);
+}
+
+async function conversationActionRequest(url) {
+  if (!areNetworkRequestsEnabled()) return null;
+  try {
+    const response = await fetch(`${BASE}${url}`, {
+      signal: requestTimeoutSignal(LONG_REQUEST_TIMEOUT_MS),
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...authHeaders() },
+      body: '{}',
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) return { ...(payload || {}), ok: false, status: response.status };
+    noteFetchSuccess();
+    return payload || { ok: true };
+  } catch (error) {
+    noteFetchFailure(url, error);
+    return null;
+  }
+}
+
 export async function deleteConversation(id) {
   const convId = String(id || '').trim();
   if (!convId || !areNetworkRequestsEnabled()) return null;
@@ -785,12 +909,31 @@ export async function updateConversationTitle(id, title) {
   });
 }
 
-export async function updateConversationPreferences(id, preferences = {}) {
+// The commit attribution a repo folder's Claude sessions use (null = the
+// provider setting). Keyed by the workspace root path.
+export async function loadWorkspaceRootAttribution(path) {
+  const root = String(path || '').trim();
+  if (!root) return null;
+  return apiFetch(`/api/workspace-root/attribution?path=${encodeURIComponent(root)}`);
+}
+
+export async function updateWorkspaceRootAttribution(path, attributionMode) {
+  const root = String(path || '').trim();
+  if (!root) return null;
+  return apiFetch('/api/workspace-root/attribution', {
+    method: 'POST',
+    body: JSON.stringify({ path: root, attributionMode: attributionMode || null }),
+  });
+}
+
+// `keepalive` lets the request outlive the page (a save made while it closes).
+export async function updateConversationPreferences(id, preferences = {}, { keepalive = false } = {}) {
   const convId = String(id || '').trim();
   if (!convId) return null;
   return apiFetch(`/api/conversation/${convId}/preferences`, {
     method: 'PATCH',
     body: JSON.stringify(preferences || {}),
+    ...(keepalive ? { keepalive: true } : {}),
   });
 }
 

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

@@ -13,6 +13,7 @@ import {
   showTransientRelayNotice,
   getConversationCurrentWorkspaceRootPath,
   IS_SHARED_VIEW,
+  conversations,
 } from './store.js';
 import { openAnnotateEditor } from './annotate-editor.js';
 import {
@@ -61,6 +62,11 @@ import {
   writeRepoBrowserHiddenPreference,
 } from './repo-browser-preferences.mjs';
 import { joinLaunchCwdPath } from './launch-cwd-path.mjs';
+import {
+  cloudAttachmentRejectionNotice,
+  isClaudeCloudConversation,
+  partitionCloudAttachments,
+} from './claude-cloud-ui.mjs';
 
 function currentConversationId() {
   return String(currentConvId || '').trim();
@@ -509,7 +515,7 @@ export async function ingestFiles(files, { source = 'picker' } = {}) {
   // conversations, and the result must never land in the wrong composer.
   const ownerConversationId = currentConversationId();
   const now = new Date();
-  const prepared = [];
+  let prepared = [];
   for (let index = 0; index < inputFiles.length; index += 1) {
     prepared.push(await prepareIncomingFile(inputFiles[index], { source, now, index }));
   }
@@ -519,6 +525,19 @@ export async function ingestFiles(files, { source = 'picker' } = {}) {
     return [];
   }
 
+  // A Claude Cloud session takes inline images only; anything else would be
+  // refused by its worker with the whole turn. Checked after the re-encode
+  // above, which is what brings a large photo under the size limit.
+  if (isClaudeCloudConversation(conversations[ownerConversationId])) {
+    const { accepted, rejected } = partitionCloudAttachments(prepared);
+    if (rejected.length) {
+      for (const { attachment } of rejected) releaseAttachmentPreviewUrl(attachment);
+      showTransientRelayNotice(cloudAttachmentRejectionNotice(rejected), 7000);
+      prepared = accepted;
+      if (!prepared.length) return [];
+    }
+  }
+
   const plan = planAttachmentMerge(selectedAttachments, prepared, MAX_UPLOAD_ATTACHMENTS);
   const rejected = prepared.filter((item) => !plan.acceptedAdditions.includes(item));
   for (const item of rejected) {

package/server/public/app/attribution-control.mjs

@@ -0,0 +1,46 @@
+// The commit-attribution row of the 🧠 context modal (Claude sessions only):
+// what this repo folder's commits say, and a select to override the provider
+// setting for the folder — the payload comes from /api/context (`attribution`).
+
+const MODE_LABELS = Object.freeze({
+  oar: 'OAR — Open Agent Relay (model)',
+  vanilla: 'Vanilla — Claude Code\'s own',
+  off: 'Off — none',
+});
+
+function esc(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+export function attributionEffectText({ effectiveMode, attributionExample } = {}) {
+  if (effectiveMode === 'vanilla') return 'Commits keep Claude Code\'s own attribution.';
+  if (effectiveMode === 'off') return 'Commits and pull requests carry no attribution line.';
+  const trailer = String(attributionExample || '').trim();
+  return trailer ? `Commits end with: ${trailer}` : 'Commits end with the Open Agent Relay trailer.';
+}
+
+/**
+ * @param {object|null} attribution the `attribution` field of an /api/context response
+ * @returns {string} the row's HTML, or '' when the payload has no folder to speak of
+ */
+export function renderAttributionControlHtml(attribution) {
+  if (!attribution || typeof attribution !== 'object') return '';
+  const path = String(attribution.path || '').trim();
+  if (!path) return '';
+  const folderMode = ['oar', 'vanilla', 'off'].includes(attribution.attributionMode) ? attribution.attributionMode : '';
+  const providerMode = ['oar', 'vanilla', 'off'].includes(attribution.providerMode) ? attribution.providerMode : 'oar';
+  const options = [
+    `<option value=""${folderMode === '' ? ' selected' : ''}>Inherit (provider: ${esc(MODE_LABELS[providerMode].split(' — ')[0])})</option>`,
+    ...['oar', 'vanilla', 'off'].map((mode) => `<option value="${mode}"${folderMode === mode ? ' selected' : ''}>${esc(MODE_LABELS[mode])}</option>`),
+  ].join('');
+  return `
+    <div class="ctx-attribution" data-workspace-root="${esc(path)}">
+      <div class="ctx-attribution-row">
+        <span class="ctx-attribution-label">Commit attribution:</span>
+        <select id="ctx-attribution-select" class="ctx-attribution-select" aria-label="Commit attribution for this folder" data-workspace-root="${esc(path)}">${options}</select>
+      </div>
+      <div class="ctx-attribution-note">For every Claude session in <code>${esc(path)}</code>. ${esc(attributionEffectText(attribution))} A change reaches running sessions with their next message.</div>
+    </div>
+  `;
+}