@oar-sh/oar 0.9.6 → 0.9.8

package/server/migrations/0007-claude-cloud.mjs

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * Migration: storage for Claude Cloud conversations (provider `claude-cloud`).
+ *
+ * 1. `runtime_sessions.claude_cloud_session_id` — the cloud session a
+ *    conversation runs in, reported by its worker after the first message
+ *    (the per-provider native id, next to `claude_native_session_id`,
+ *    `cursor_agent_id` and `grok_native_session_id`).
+ * 2. `runtime_sessions.claude_cloud_last_sequence` — the last event sequence
+ *    the worker has handled: where it resumes the event stream after a restart.
+ * 3. `runtime_sessions.claude_cloud_cost_usd` — what the session has cost so
+ *    far, as the cloud reports it.
+ * 4. `conversations.cloud_source_json` — what the session clones and where it
+ *    is shown: `{ repoUrl, branch, environmentId, sessionUrl,
+ *    pushedBranches: [{ branch, at }] }`.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0007-claude-cloud.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+const COLUMNS = Object.freeze([
+  Object.freeze({ table: 'runtime_sessions', name: 'claude_cloud_session_id', type: 'TEXT' }),
+  Object.freeze({ table: 'runtime_sessions', name: 'claude_cloud_last_sequence', type: 'TEXT' }),
+  Object.freeze({ table: 'runtime_sessions', name: 'claude_cloud_cost_usd', type: 'REAL' }),
+  Object.freeze({ table: 'conversations', name: 'cloud_source_json', type: 'TEXT' }),
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => String(column.name)));
+}
+
+export function migrateClaudeCloud(db) {
+  let columnsAdded = 0;
+  for (const column of COLUMNS) {
+    if (!tableExists(db, column.table)) continue;
+    if (columnNames(db, column.table).has(column.name)) continue;
+    db.exec(`ALTER TABLE ${column.table} ADD COLUMN ${column.name} ${column.type}`);
+    columnsAdded += 1;
+  }
+  return { applied: columnsAdded > 0, columnsAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateClaudeCloud(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0007 on ${dbPath}`);
+    console.log(result.applied ? `  claude cloud columns added: ${result.columnsAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0007 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

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

@@ -18,10 +18,44 @@ export function normalizeRelayActivityEntry(item) {
 // 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.
+// Every compaction entry answers here, whatever its state: the live bubble
+// never shows any of them as prose.
 export function isCompactBoundaryActivityEntry(item) {
   return normalizeRelayActivityEntry(item)?.metadata?.kind === 'compact_boundary';
 }
 
+// The live list of one turn keeps its newest ordinary lines only, but every
+// structured row a line of the transcript is built from: the turn's
+// compaction entries and the session-restart note would otherwise scroll out
+// of a busy turn and take their line with them until the next reload.
+export const LIVE_ACTIVITY_CAP = 24;
+function isKeptLiveActivityEntry(item) {
+  const kind = normalizeRelayActivityEntry(item)?.metadata?.kind;
+  return kind === 'compact_boundary' || kind === 'compact_window_respawn';
+}
+export function capLiveActivityEntries(items, cap = LIVE_ACTIVITY_CAP) {
+  const list = Array.isArray(items) ? items : [];
+  let ordinary = list.reduce((count, item) => count + (isKeptLiveActivityEntry(item) ? 0 : 1), 0);
+  if (ordinary <= cap) return list;
+  return list.filter((item) => {
+    if (isKeptLiveActivityEntry(item)) return true;
+    ordinary -= 1;
+    return ordinary < cap;
+  });
+}
+
+// A compaction is published in up to two steps on the same message: a
+// `pending` entry when it starts, then either the boundary (no `state`, token
+// counts) or a `cancelled` entry when it ended without a result.
+// → 'pending' | 'cancelled' | 'boundary' | null (not a compaction entry).
+export function compactionEntryState(item) {
+  const metadata = normalizeRelayActivityEntry(item)?.metadata;
+  if (metadata?.kind !== 'compact_boundary') return null;
+  const state = String(metadata.state || '').trim().toLowerCase();
+  if (state === 'pending' || state === 'cancelled') return state;
+  return '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.
@@ -34,19 +68,36 @@ function toTokenCount(value) {
 // 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) {
+//
+// The last compaction entry decides: a `pending` one is promoted only while
+// the message is still `processing` (a finished or failed message never shows
+// a dangling start). A dangling start or a `cancelled` end draws no line of
+// its own, so the line falls back to an earlier boundary of the same message
+// when there is one.
+export function promotedCompactBoundaryEntry(items, { processing = false } = {}) {
   const list = Array.isArray(items) ? items : [];
+  let sawLast = false;
   for (let index = list.length - 1; index >= 0; index -= 1) {
-    if (isCompactBoundaryActivityEntry(list[index])) return list[index];
+    const state = compactionEntryState(list[index]);
+    if (!state) continue;
+    if (!sawLast) {
+      sawLast = true;
+      if (state === 'pending' && processing) return list[index];
+    }
+    if (state === 'boundary') 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);
+// { preTokens, postTokens } (either may be null when the SDK omitted it), or
+// { pending: true, preTokens: null, postTokens: null } while it runs.
+export function compactBoundaryFromActivities(items, options = {}) {
+  const promoted = promotedCompactBoundaryEntry(items, options);
   if (!promoted) return null;
+  if (compactionEntryState(promoted) === 'pending') {
+    return { pending: true, preTokens: null, postTokens: null };
+  }
   const metadata = normalizeRelayActivityEntry(promoted).metadata;
   return {
     preTokens: toTokenCount(metadata.preTokens),
@@ -54,6 +105,18 @@ export function compactBoundaryFromActivities(items) {
   };
 }
 
+// Activity rows the message bubble lists as prose: everything except the
+// promoted boundary (it is the break row) and every pending/cancelled step
+// (transient state, never prose).
+export function visibleActivityEntries(items, promoted) {
+  const list = Array.isArray(items) ? items : [];
+  return list.filter((item) => {
+    if (item === promoted) return false;
+    const state = compactionEntryState(item);
+    return state !== 'pending' && state !== 'cancelled';
+  });
+}
+
 // 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

package/server/public/app/agent-sessions-settings-ui.js

@@ -0,0 +1,197 @@
+// Settings → Relays → Agent sessions: the switch that lets agents start and use
+// sessions on this relay through the remote_relay tool, and the slider for the
+// longest wait of one tool call. The decisions live in
+// agent-sessions-settings.mjs; this file only moves them into the markup in
+// index.html. The static controls use inline handlers that bootstrap.js
+// exposes on window.
+//
+// The section ships hidden. It shows once the relay answered with settings and
+// stays hidden on a relay that does not know the route (404).
+
+import { loadAgentSessionsSettings, updateAgentSessionsSettings } from './api-client.js';
+import {
+  agentSessionsSavedText,
+  agentSessionsViewModel,
+  clampWaitSeconds,
+  classifyAgentSessionsLoad,
+  formatWaitMinutesLabel,
+  normalizeAgentSessionsSettings,
+} from './agent-sessions-settings.mjs';
+
+// null until the first successful read: "never answered" is not "off".
+let settingsState = null;
+let unsupported = false;
+let loadFailed = false;
+let saveInFlight = false;
+// What is being saved, drawn over the stored state until the relay answers so
+// the switch and the thumb stay where the user put them.
+let pendingChange = null;
+// A value from elsewhere arrived while the slider had focus; drawn on blur.
+let sliderRenderDeferred = false;
+let sliderBlurBound = false;
+
+function el(id) {
+  return document.getElementById(id);
+}
+
+export function getAgentSessionsSettings() {
+  return settingsState;
+}
+
+function setStatusLine(state, text) {
+  const line = el('agent-sessions-status');
+  if (!line) return;
+  line.textContent = text || '';
+  line.hidden = !text;
+  if (state) line.dataset.state = state;
+  else delete line.dataset.state;
+}
+
+function setSliderLabel(text) {
+  const label = el('agent-sessions-max-wait-value');
+  if (label) label.textContent = text;
+  // The value is in seconds; a screen reader hears the minutes.
+  el('agent-sessions-max-wait-slider')?.setAttribute('aria-valuetext', text);
+}
+
+function bindSliderBlur(slider) {
+  if (sliderBlurBound) return;
+  sliderBlurBound = true;
+  slider.addEventListener('blur', () => {
+    if (sliderRenderDeferred) renderAgentSessionsSection({ forceSlider: true });
+  });
+}
+
+/**
+ * Idempotent. A value that came from elsewhere (socket, refresh) never moves
+ * the thumb under the user's finger: it waits until focus leaves the slider.
+ * `forceSlider` is for this page's own saves.
+ */
+export function renderAgentSessionsSection({ forceSlider = false } = {}) {
+  const section = el('agent-sessions-section');
+  if (!section) return;
+  const view = agentSessionsViewModel({
+    settings: settingsState && pendingChange ? { ...settingsState, ...pendingChange } : settingsState,
+    unsupported,
+    loadFailed,
+    saving: saveInFlight,
+  });
+  section.hidden = view.hidden;
+
+  const toggle = el('agent-sessions-enabled-toggle');
+  if (toggle) {
+    toggle.checked = view.toggle.checked;
+    toggle.disabled = view.toggle.disabled;
+  }
+
+  const slider = el('agent-sessions-max-wait-slider');
+  if (slider) {
+    bindSliderBlur(slider);
+    slider.disabled = view.slider.disabled;
+    const held = !forceSlider && !view.slider.disabled && document.activeElement === slider;
+    sliderRenderDeferred = held;
+    if (!held) {
+      // Range first: a value outside the old range would be clamped by the input.
+      slider.min = String(view.slider.min);
+      slider.max = String(view.slider.max);
+      slider.step = String(view.slider.step);
+      slider.value = String(view.slider.value);
+      setSliderLabel(view.slider.label);
+    }
+  }
+
+  const cap = el('agent-sessions-cap');
+  if (cap) {
+    cap.textContent = view.capText;
+    cap.hidden = !view.capText;
+  }
+}
+
+// Single entry point for every payload (GET, POST answer, socket event).
+export function applyAgentSessionsSettingsState(payload, { forceSlider = false } = {}) {
+  if (!payload || typeof payload !== 'object') return settingsState;
+  settingsState = normalizeAgentSessionsSettings(payload, settingsState);
+  unsupported = false;
+  loadFailed = false;
+  renderAgentSessionsSection({ forceSlider });
+  return settingsState;
+}
+
+/** Called when the settings modal opens, and for a socket event without a body. */
+export async function refreshAgentSessionsSection() {
+  if (!saveInFlight) setStatusLine('', '');
+  renderAgentSessionsSection();
+  const result = await loadAgentSessionsSettings();
+  const outcome = classifyAgentSessionsLoad(result);
+  if (outcome === 'loaded') return applyAgentSessionsSettingsState(result);
+  if (outcome === 'unsupported') {
+    unsupported = true;
+    settingsState = null;
+  } else if (!settingsState) {
+    // Keep what an earlier read said: one failed refresh is not "gone".
+    loadFailed = true;
+    setStatusLine('error', 'Could not load the agent session settings from this relay.');
+  }
+  renderAgentSessionsSection();
+  return settingsState;
+}
+
+async function saveAgentSessionsChange(change, patch, failureText) {
+  saveInFlight = true;
+  pendingChange = patch;
+  setStatusLine('saved', 'Saving…');
+  renderAgentSessionsSection({ forceSlider: true });
+  let result = null;
+  try {
+    result = await updateAgentSessionsSettings(patch);
+  } finally {
+    saveInFlight = false;
+    pendingChange = null;
+  }
+  if (result?.ok) {
+    // The relay's answer is the truth (it may have clamped the wait).
+    applyAgentSessionsSettingsState({ ...patch, ...result }, { forceSlider: true });
+    setStatusLine('active', agentSessionsSavedText(change, settingsState));
+  } else {
+    // Back to what the relay has; the line says why.
+    setStatusLine('error', result?.error || failureText);
+    renderAgentSessionsSection({ forceSlider: true });
+  }
+}
+
+export async function toggleAgentSessions(checked) {
+  if (saveInFlight || !settingsState) {
+    renderAgentSessionsSection();
+    return;
+  }
+  await saveAgentSessionsChange('enabled', { enabled: checked === true }, 'Failed to update the setting.');
+}
+
+/** Live label feedback while dragging; nothing is saved until change fires. */
+export function previewAgentSessionsMaxWait(value) {
+  const seconds = clampWaitSeconds(value, settingsState?.limits, settingsState?.maxWaitSeconds);
+  setSliderLabel(formatWaitMinutesLabel(seconds));
+}
+
+export async function saveAgentSessionsMaxWait(value) {
+  if (saveInFlight || !settingsState) {
+    renderAgentSessionsSection({ forceSlider: true });
+    return;
+  }
+  const seconds = clampWaitSeconds(value, settingsState.limits, settingsState.maxWaitSeconds);
+  if (seconds === settingsState.maxWaitSeconds) {
+    renderAgentSessionsSection({ forceSlider: true });
+    return;
+  }
+  await saveAgentSessionsChange('maxWaitSeconds', { maxWaitSeconds: seconds }, 'Failed to save the longest wait.');
+}
+
+/** Test hook. */
+export function resetAgentSessionsSettingsForTests() {
+  settingsState = null;
+  unsupported = false;
+  loadFailed = false;
+  saveInFlight = false;
+  pendingChange = null;
+  sliderRenderDeferred = false;
+}

package/server/public/app/agent-sessions-settings.mjs

@@ -0,0 +1,134 @@
+// Pure helpers for Settings → Relays → Agent sessions: whether agents may
+// start and use sessions on this relay, and the longest time one remote_relay
+// call may wait. DOM-free on purpose, like claude-cloud-ui.mjs: the section
+// (agent-sessions-settings-ui.js) owns the elements, this module the decisions.
+//
+// One payload shape everywhere — GET and POST /api/settings/agent-sessions and
+// the `agent_sessions_settings_updated` socket event:
+//   { enabled, maxWaitSeconds, limits: { minWaitSeconds, maxWaitSeconds, stepSeconds }, maxActiveSessions }
+// The relay stores seconds; the slider works in seconds too and only its label
+// speaks minutes.
+
+export const AGENT_SESSIONS_SOCKET_EVENT = 'agent_sessions_settings_updated';
+
+// What the relay enforces when it says nothing else; the markup starts there.
+export const AGENT_SESSIONS_DEFAULT_WAIT_SECONDS = 600;
+export const AGENT_SESSIONS_DEFAULT_LIMITS = Object.freeze({
+  minWaitSeconds: 120,
+  maxWaitSeconds: 3600,
+  stepSeconds: 60,
+});
+
+function positiveNumber(value) {
+  // No coercion of null, '' or true into a number.
+  if (typeof value !== 'number' && (typeof value !== 'string' || !value.trim())) return null;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : null;
+}
+
+/** The slider's range and step in seconds; anything unusable falls back. */
+export function normalizeAgentSessionsLimits(raw, fallback = AGENT_SESSIONS_DEFAULT_LIMITS) {
+  const minWaitSeconds = positiveNumber(raw?.minWaitSeconds) ?? fallback.minWaitSeconds;
+  const maxCandidate = positiveNumber(raw?.maxWaitSeconds) ?? fallback.maxWaitSeconds;
+  return {
+    minWaitSeconds,
+    maxWaitSeconds: Math.max(minWaitSeconds, maxCandidate),
+    stepSeconds: positiveNumber(raw?.stepSeconds) ?? fallback.stepSeconds,
+  };
+}
+
+/**
+ * A wait the relay will accept: inside the limits and on a step counted from
+ * the minimum. Something that is not a number becomes `fallback`, clamped the
+ * same way.
+ */
+export function clampWaitSeconds(value, limits = AGENT_SESSIONS_DEFAULT_LIMITS, fallback = AGENT_SESSIONS_DEFAULT_WAIT_SECONDS) {
+  const { minWaitSeconds: min, maxWaitSeconds: max, stepSeconds: step } = normalizeAgentSessionsLimits(limits);
+  const wanted = positiveNumber(value) ?? positiveNumber(fallback) ?? min;
+  const bounded = Math.min(max, Math.max(min, wanted));
+  const stepped = min + Math.round((bounded - min) / step) * step;
+  // The last step may overshoot a maximum that is not on the grid.
+  return stepped > max ? min + Math.floor((max - min) / step) * step : stepped;
+}
+
+/** 600 → "10 min", 150 → "2.5 min"; '' for something that is not a duration. */
+export function formatWaitMinutesLabel(seconds) {
+  const value = positiveNumber(seconds);
+  if (value === null) return '';
+  return `${Math.round((value / 60) * 10) / 10} min`;
+}
+
+/**
+ * The section's state from a payload. A field the payload does not carry keeps
+ * what `previous` had (the first payload falls back to "off" and the defaults).
+ */
+export function normalizeAgentSessionsSettings(payload, previous = null) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return previous;
+  const limits = payload.limits && typeof payload.limits === 'object'
+    ? normalizeAgentSessionsLimits(payload.limits)
+    : (previous?.limits || { ...AGENT_SESSIONS_DEFAULT_LIMITS });
+  const maxActive = positiveNumber(payload.maxActiveSessions);
+  return {
+    enabled: typeof payload.enabled === 'boolean' ? payload.enabled : previous?.enabled === true,
+    maxWaitSeconds: positiveNumber(payload.maxWaitSeconds)
+      ?? previous?.maxWaitSeconds
+      ?? AGENT_SESSIONS_DEFAULT_WAIT_SECONDS,
+    limits,
+    maxActiveSessions: maxActive !== null ? Math.floor(maxActive) : (previous?.maxActiveSessions ?? null),
+  };
+}
+
+/**
+ * What an answer to the GET means for the section:
+ *   'loaded'      — the settings; show the section.
+ *   'unsupported' — an older relay without the route (404, or a 200 that is not
+ *                   the settings); hide the section.
+ *   'failed'      — the relay could not be asked (offline, paused, 5xx); keep
+ *                   what is shown.
+ */
+export function classifyAgentSessionsLoad(result) {
+  if (!result || typeof result !== 'object') return 'failed';
+  if (result.ok === true) return typeof result.enabled === 'boolean' ? 'loaded' : 'unsupported';
+  return Number(result.status) === 404 ? 'unsupported' : 'failed';
+}
+
+/**
+ * Everything the section draws, from its state. `settings` is null until the
+ * relay answered; `unsupported` hides the section for good; `loadFailed` shows
+ * it switched off with a note when the very first read failed.
+ */
+export function agentSessionsViewModel({ settings = null, unsupported = false, loadFailed = false, saving = false } = {}) {
+  const known = !!settings && !unsupported;
+  const limits = normalizeAgentSessionsLimits(settings?.limits);
+  const value = positiveNumber(settings?.maxWaitSeconds) ?? AGENT_SESSIONS_DEFAULT_WAIT_SECONDS;
+  const cap = positiveNumber(settings?.maxActiveSessions);
+  return {
+    hidden: unsupported || (!settings && !loadFailed),
+    toggle: {
+      checked: known && settings.enabled === true,
+      disabled: !known || saving,
+    },
+    slider: {
+      min: limits.minWaitSeconds,
+      max: limits.maxWaitSeconds,
+      step: limits.stepSeconds,
+      value,
+      label: formatWaitMinutesLabel(value),
+      // Not tied to the switch: the limit also governs waits on paired relays.
+      disabled: !known || saving,
+    },
+    capText: known && cap !== null
+      ? `At most ${Math.floor(cap)} of them work at the same time per conversation.`
+      : '',
+  };
+}
+
+/** The status line after a save the relay accepted. */
+export function agentSessionsSavedText(change, settings) {
+  if (change === 'enabled') {
+    return settings?.enabled === true
+      ? 'Agents may start and use sessions on this relay now.'
+      : 'Agents can no longer start or use sessions on this relay.';
+  }
+  return `Agents may wait up to ${formatWaitMinutesLabel(settings?.maxWaitSeconds)} per tool call.`;
+}