@oar-sh/oar 0.9.23 → 0.9.25

package/server/services/plan-usage-openai-image.mjs

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * OpenAI images on the Check Usage modal (provider `openai`, the booking's
+ * provider, so the Tokens sections of plan-usage-tokens.mjs land on it).
+ *
+ * The figures are the spend state of shared/openai-image-spend.mjs: today
+ * and this month in the relay's local days, booked by OAR from its price
+ * table, estimates and the stand-in price of an unknown model included (they
+ * count toward the cap on purpose). The card shows the daily cap as a meter,
+ * the warning share, the owner's "Allow for today", and how much of today is
+ * estimated. The raw state rides along as `imageSpend` for the browser's cap
+ * bar.
+ */
+
+import {
+  SOURCE_WORKER,
+  STATUS_OK,
+  STATUS_UNAVAILABLE,
+  buildMeter,
+  buildProviderCard,
+  roundCurrency,
+  toFiniteNumber,
+} from './plan-usage-contract.mjs';
+import {
+  OPENAI_IMAGE_BOOKING_PROVIDER,
+  OPENAI_IMAGE_CAP_WARN_RATIO,
+  formatOpenAIImageUsd,
+} from '../../shared/openai-image-spend.mjs';
+
+export const OPENAI_IMAGE_CARD_LABEL = 'OpenAI images';
+
+const OPENAI_USAGE_URL = 'https://platform.openai.com/usage';
+
+const usd = (value) => Math.max(0, toFiniteNumber(value) ?? 0);
+
+/**
+ * The card, or null when there is nothing to show: OpenAI is off and nothing
+ * was booked this month. `state` is the spend state; `error` replaces it
+ * when it could not be read.
+ */
+export function buildOpenAIImagePlanCard({ state = null, error = null, configured = false } = {}) {
+  const links = [{ label: 'OpenAI usage', url: OPENAI_USAGE_URL }];
+  if (!state) {
+    if (!configured) return null;
+    return buildProviderCard({
+      provider: OPENAI_IMAGE_BOOKING_PROVIDER,
+      label: OPENAI_IMAGE_CARD_LABEL,
+      status: STATUS_UNAVAILABLE,
+      message: `This relay's OpenAI image spend could not be read${error ? `: ${error}` : ''}.`,
+      source: SOURCE_WORKER,
+      links,
+    });
+  }
+  const spent = usd(state.spentUsd);
+  const reserved = usd(state.reservedUsd);
+  const month = usd(state.monthUsd);
+  if (!configured && month <= 0 && spent <= 0 && reserved <= 0) return null;
+
+  const capUsd = toFiniteNumber(state.capUsd);
+  const hasCap = capUsd !== null && capUsd > 0;
+  const used = roundCurrency(spent + reserved);
+  const allowed = state.allowedToday === true;
+  const percent = hasCap ? Math.round((used / capUsd) * 100) : null;
+
+  const messages = [];
+  if (hasCap && state.reached === true) {
+    messages.push(allowed
+      ? `Today's image spend has reached the daily cap of ${formatOpenAIImageUsd(capUsd)}; image turns run anyway, because the owner allowed them for today.`
+      : `Today's image spend has reached the daily cap of ${formatOpenAIImageUsd(capUsd)}: new image turns are refused until tomorrow (relay time), or until the owner allows more for today (Settings → Providers → OpenAI).`);
+  } else if (hasCap && state.warning === true) {
+    messages.push(`Today's image spend is at ${percent} % of the daily cap of ${formatOpenAIImageUsd(capUsd)}.`);
+  }
+  if (!hasCap) messages.push('No daily cap is set for OpenAI images on this relay.');
+
+  const meters = [];
+  if (hasCap) {
+    meters.push(buildMeter({
+      id: 'openai-images-daily-cap',
+      label: 'Daily cap',
+      unit: 'usd',
+      used,
+      allowance: capUsd,
+      remaining: roundCurrency(Math.max(0, capUsd - used)),
+      estimated: true,
+      severity: state.reached === true ? 'reached' : (state.warning === true ? 'warning' : null),
+      note: `This relay's image spend today (${state.day || 'relay time'}), images in progress included; a warning from ${Math.round(OPENAI_IMAGE_CAP_WARN_RATIO * 100)} %, and at the cap new image turns are refused${allowed ? ' (allowed for today by the owner)' : ''}. It starts over at midnight, relay time.`,
+    }));
+  }
+
+  const estimated = usd(state.estimatedUsd);
+  const unknown = usd(state.unknownPriceUsd);
+  const notes = [
+    {
+      id: 'openai-images-today',
+      label: 'Today',
+      value: formatOpenAIImageUsd(used),
+      hint: [
+        reserved > 0 ? `${formatOpenAIImageUsd(reserved)} in progress` : '',
+        estimated > 0 ? `${formatOpenAIImageUsd(estimated)} estimated` : '',
+        unknown > 0 ? `${formatOpenAIImageUsd(unknown)} at an unknown model's stand-in price` : '',
+      ].filter(Boolean).join(' · ') || null,
+      text: `OpenAI image spend today: ${formatOpenAIImageUsd(used)}${reserved > 0 ? `, of it ${formatOpenAIImageUsd(reserved)} in progress` : ''}.`,
+    },
+    {
+      id: 'openai-images-month',
+      label: 'This month',
+      value: formatOpenAIImageUsd(month),
+      text: `OpenAI image spend this month: ${formatOpenAIImageUsd(month)}.`,
+    },
+    {
+      id: 'openai-images-override',
+      label: 'Allow for today',
+      value: allowed ? 'on' : 'off',
+      hint: allowed && state.allowedAt ? `since ${state.allowedAt}` : null,
+      text: allowed
+        ? 'The owner allowed image turns past the cap for today; it ends at midnight, relay time.'
+        : 'Past the cap, image turns are refused unless the owner allows them for today.',
+    },
+  ];
+  const conversation = state.conversation && typeof state.conversation === 'object' ? state.conversation : null;
+  if (conversation) {
+    const images = Math.max(0, Math.trunc(toFiniteNumber(conversation.images) ?? 0));
+    notes.push({
+      id: 'openai-images-this-chat',
+      label: 'This chat',
+      value: formatOpenAIImageUsd(usd(conversation.costUsd)),
+      hint: `${images} ${images === 1 ? 'image' : 'images'}`,
+      text: `OpenAI images in this chat: ${formatOpenAIImageUsd(usd(conversation.costUsd))} (${images} ${images === 1 ? 'image' : 'images'}).`,
+    });
+  }
+  notes.push({
+    id: 'openai-images-estimate',
+    text: 'Priced by OAR from its own table of OpenAI image prices, for the image turns of this relay; a try that may have been billed without a usage report counts at its estimate. OpenAI\'s usage page has every request on the key.',
+  });
+
+  const card = buildProviderCard({
+    provider: OPENAI_IMAGE_BOOKING_PROVIDER,
+    label: OPENAI_IMAGE_CARD_LABEL,
+    status: STATUS_OK,
+    message: messages.join(' ') || null,
+    source: SOURCE_WORKER,
+    meters: meters.filter(Boolean),
+    notes,
+    links,
+  });
+  return card ? { ...card, imageSpend: state } : null;
+}

package/server/services/provider-model-refresh.mjs

@@ -0,0 +1,326 @@
+'use strict';
+
+// One place for "a provider's model list was refreshed".
+//
+// The ledger keeps when each provider was last refreshed (model_refresh_last)
+// whatever asked for it: the Select Models Refresh button, a settings save, a
+// login, a CLI install, the boot discovery, a Copilot snapshot or the
+// background check (model-refresh-scheduler.mjs). Each refresh function is
+// wrapped once with `track(provider, fn)`, so every caller resets the
+// provider's clock without knowing about it. A `skipped` result (provider off,
+// CLI missing) is neither a success nor a failure. The ledger also queues the
+// models a refresh found for the first time, which the next `models_updated`
+// carries as `newModels` (the toast).
+//
+// `refreshProviderModels` is the Promise.allSettled block of
+// POST /api/model-variants/refresh, shared with the background check.
+
+import {
+  MODEL_REFRESH_AUTO_SETTING_KEY,
+  MODEL_REFRESH_EXCLUDED_SETTING_KEY,
+  MODEL_REFRESH_INTERVAL_HOURS_SETTING_KEY,
+  MODEL_REFRESH_LAST_SETTING_KEY,
+  MODEL_REFRESH_PROVIDERS,
+  modelRefreshProvider,
+  parseModelRefreshAutoUpdate,
+  parseModelRefreshExcludedUpdate,
+  parseModelRefreshIntervalHoursUpdate,
+  readModelRefreshAutoSetting,
+  readModelRefreshExcludedSetting,
+  readModelRefreshIntervalHoursSetting,
+  readModelRefreshLastSetting,
+} from '../../shared/model-refresh-schedule.mjs';
+
+const SKIPPED = Object.freeze({ ok: true, skipped: true, models: [], error: null });
+// What a failed refresh keeps of its error text.
+export const MODEL_REFRESH_ERROR_MAX_CHARS = 240;
+const REDACTED = '[redacted]';
+
+/**
+ * A refresh error without the provider's secrets: each one given is cut out
+ * wherever it appears, and so is whatever follows "Bearer" or an
+ * Authorization header an answer echoed back. Then capped.
+ */
+export function redactModelRefreshError(text, secrets = []) {
+  let out = String(text ?? '');
+  for (const secret of Array.isArray(secrets) ? secrets : []) {
+    const value = String(secret ?? '').trim();
+    if (value.length >= 4) out = out.split(value).join(REDACTED);
+  }
+  out = out
+    .replace(/\b(authorization\s*["']?\s*[:=]\s*["']?)(?:bearer\s+)?[^\s"',;}]+/gi, `$1${REDACTED}`)
+    .replace(/\bbearer\s+(?!\[redacted\])[^\s"',;}]+/gi, `Bearer ${REDACTED}`)
+    .replace(/\s+/g, ' ')
+    .trim();
+  return out.length > MODEL_REFRESH_ERROR_MAX_CHARS ? `${out.slice(0, MODEL_REFRESH_ERROR_MAX_CHARS - 1)}…` : out;
+}
+
+/**
+ * A failed refresh in a log line: its HTTP status, a timeout, or the words
+ * before the first colon, never the answer's body.
+ */
+export function modelRefreshErrorSummary(text) {
+  const value = String(text ?? '');
+  const status = value.match(/\((\d{3})\)/) || value.match(/\b(?:status|HTTP)\s*:?\s*(\d{3})\b/i);
+  if (status) return `HTTP ${status[1]}`;
+  if (/timed out|timeout/i.test(value)) return 'timed out';
+  const head = value.split(':')[0].replace(/\s+/g, ' ').trim();
+  return (head || 'unknown error').slice(0, 80);
+}
+
+function isoOf(value) {
+  const date = value instanceof Date ? value : new Date(value ?? Date.now());
+  return Number.isFinite(date.getTime()) ? date.toISOString() : new Date().toISOString();
+}
+
+export function createModelRefreshLedger({
+  readSetting = () => '',
+  writeSetting = null,
+  now = () => new Date(),
+  // (provider) => the secrets its errors may carry (API keys, tokens): cut
+  // out before an error is stored, answered by the settings route or logged.
+  secretsFor = () => [],
+} = {}) {
+  let pendingNewModels = [];
+
+  function readLast() {
+    try {
+      return readModelRefreshLastSetting(readSetting(MODEL_REFRESH_LAST_SETTING_KEY));
+    } catch {
+      return {};
+    }
+  }
+
+  /** New models of one provider for the next models_updated; one entry per provider and state. */
+  function noteNewModels(provider, added = []) {
+    const meta = modelRefreshProvider(provider);
+    if (!meta) return;
+    for (const { id, on } of Array.isArray(added) ? added : []) {
+      const modelId = String(id || '').trim();
+      if (!modelId) continue;
+      let entry = pendingNewModels.find((candidate) => candidate.provider === meta.id && candidate.on === (on === true));
+      if (!entry) {
+        entry = { provider: meta.id, tab: meta.tab, label: meta.label, ids: [], on: on === true };
+        pendingNewModels.push(entry);
+      }
+      if (!entry.ids.includes(modelId)) entry.ids.push(modelId);
+    }
+  }
+
+  /** The queued new models, emptied. */
+  function takeNewModels() {
+    const taken = pendingNewModels;
+    pendingNewModels = [];
+    return taken;
+  }
+
+  function secretsOf(provider) {
+    try {
+      const secrets = secretsFor(provider);
+      return Array.isArray(secrets) ? secrets : [];
+    } catch {
+      return [];
+    }
+  }
+
+  /** Notes one refresh result; returns the provider's entry, or null when skipped. */
+  function record(provider, result) {
+    const meta = modelRefreshProvider(provider);
+    if (!meta || !result || typeof result !== 'object' || result.skipped === true) return null;
+    const stamp = isoOf(now());
+    const ok = result.ok === true;
+    const last = readLast();
+    const previous = last[meta.id] || {};
+    last[meta.id] = {
+      at: stamp,
+      ok,
+      error: ok ? null : (redactModelRefreshError(result.error || 'Model refresh failed', secretsOf(meta.id)) || 'Model refresh failed'),
+      lastOkAt: ok ? stamp : (previous.lastOkAt || null),
+      lastFailureAt: ok ? (previous.lastFailureAt || null) : stamp,
+    };
+    try {
+      writeSetting?.(MODEL_REFRESH_LAST_SETTING_KEY, JSON.stringify(last), stamp);
+    } catch {
+      /* the clock is best-effort; the next refresh writes it again */
+    }
+    if (ok) noteNewModels(meta.id, result.newModels);
+    return last[meta.id];
+  }
+
+  /** `fn` with every call noted against `provider`; a throw counts as a failure. */
+  function track(provider, fn) {
+    if (typeof fn !== 'function') return fn;
+    return async (...args) => {
+      let result;
+      try {
+        result = await fn(...args);
+      } catch (error) {
+        record(provider, { ok: false, error: error?.message || String(error || 'Model refresh failed') });
+        throw error;
+      }
+      record(provider, result);
+      return result;
+    };
+  }
+
+  return { readLast, record, track, noteNewModels, takeNewModels };
+}
+
+/** The check's own settings: `{ auto, intervalHours, excluded }`. */
+export function createModelRefreshSettings({
+  readSetting = () => '',
+  writeSetting = null,
+  now = () => new Date(),
+} = {}) {
+  function get() {
+    return {
+      auto: readModelRefreshAutoSetting(readSetting(MODEL_REFRESH_AUTO_SETTING_KEY)),
+      intervalHours: readModelRefreshIntervalHoursSetting(readSetting(MODEL_REFRESH_INTERVAL_HOURS_SETTING_KEY)),
+      excluded: readModelRefreshExcludedSetting(readSetting(MODEL_REFRESH_EXCLUDED_SETTING_KEY)),
+    };
+  }
+
+  /** Checks every field given before writing any; `{ ok, settings }` or `{ ok: false, error }`. */
+  function update(body = {}) {
+    const payload = body && typeof body === 'object' && !Array.isArray(body) ? body : {};
+    const has = (key) => Object.prototype.hasOwnProperty.call(payload, key);
+    if (!has('auto') && !has('intervalHours') && !has('excluded')) return { ok: false, error: 'No model refresh settings update provided' };
+    const auto = has('auto') ? parseModelRefreshAutoUpdate(payload.auto) : null;
+    const interval = has('intervalHours') ? parseModelRefreshIntervalHoursUpdate(payload.intervalHours) : null;
+    const excluded = has('excluded') ? parseModelRefreshExcludedUpdate(payload.excluded) : null;
+    const refused = [auto, interval, excluded].find((parsed) => parsed && !parsed.ok);
+    if (refused) return { ok: false, error: refused.error };
+    if (typeof writeSetting !== 'function') return { ok: false, error: 'Model refresh settings are unavailable' };
+    const stamp = isoOf(now());
+    if (auto) writeSetting(MODEL_REFRESH_AUTO_SETTING_KEY, auto.auto ? 'true' : 'false', stamp);
+    if (interval) writeSetting(MODEL_REFRESH_INTERVAL_HOURS_SETTING_KEY, String(interval.intervalHours), stamp);
+    if (excluded) writeSetting(MODEL_REFRESH_EXCLUDED_SETTING_KEY, JSON.stringify(excluded.excluded), stamp);
+    return { ok: true, settings: get() };
+  }
+
+  return { get, update };
+}
+
+/**
+ * The providers the refresh can ask, from the route deps: `isEnabled` gates
+ * the Refresh button (a provider that is off is skipped), `isSetUp` the
+ * background check (Copilot: an installed CLI; Claude and Grok: their CLI
+ * or their login; the others: switched on, which needs their key),
+ * `currentModels` is what a failed refresh answers with.
+ */
+export function buildProviderRefreshTable({
+  getOpenAIProviderSettings = () => null,
+  refreshOpenAIProviderModels = null,
+  getClaudeProviderSettings = () => null,
+  refreshClaudeProviderModels = null,
+  getCursorProviderSettings = () => null,
+  refreshCursorProviderModels = null,
+  getGrokProviderSettings = () => null,
+  refreshGrokProviderModels = null,
+  deepseekSettingsService = null,
+  claudeApiSettingsService = null,
+  copilotModelDiscoveryService = null,
+  // Claude and Grok run on the host's CLI and its login: set up when the CLI
+  // is installed or the login is there, as the relay knows it without
+  // spawning anything. Absent (most tests): enabled is enough.
+  isClaudeSetUp = () => true,
+  isGrokSetUp = () => true,
+} = {}) {
+  const enabledOf = (getSettings) => () => {
+    try {
+      return getSettings?.()?.enabled === true;
+    } catch {
+      return false;
+    }
+  };
+  const modelsOf = (getSettings) => () => {
+    try {
+      const models = getSettings?.()?.models;
+      return Array.isArray(models) ? models : [];
+    } catch {
+      return [];
+    }
+  };
+  const entry = (getSettings, refresh, setUp = () => true) => ({
+    isEnabled: enabledOf(getSettings),
+    isSetUp: () => {
+      if (!enabledOf(getSettings)()) return false;
+      try {
+        return setUp() === true;
+      } catch {
+        return false;
+      }
+    },
+    currentModels: modelsOf(getSettings),
+    refresh: typeof refresh === 'function' ? () => refresh() : null,
+  });
+  const deepseekSettings = () => deepseekSettingsService?.getSettings?.() || null;
+  const claudeApiSettings = () => claudeApiSettingsService?.getSettings?.() || null;
+  const hasCopilotDiscovery = typeof copilotModelDiscoveryService?.refresh === 'function';
+  return {
+    // Copilot discovery gates itself on an installed CLI (skipped when there
+    // is none), so the Refresh button always asks it.
+    github: {
+      isEnabled: () => hasCopilotDiscovery,
+      isSetUp: () => {
+        if (!hasCopilotDiscovery) return false;
+        try {
+          return typeof copilotModelDiscoveryService.isCliResolvable === 'function'
+            ? copilotModelDiscoveryService.isCliResolvable() === true
+            : true;
+        } catch {
+          return false;
+        }
+      },
+      currentModels: () => [],
+      refresh: hasCopilotDiscovery ? (reason) => copilotModelDiscoveryService.refresh(reason) : null,
+    },
+    openai: entry(getOpenAIProviderSettings, refreshOpenAIProviderModels),
+    claude: entry(getClaudeProviderSettings, refreshClaudeProviderModels, isClaudeSetUp),
+    'claude-api': entry(claudeApiSettings, claudeApiSettingsService?.refreshModels),
+    cursor: entry(getCursorProviderSettings, refreshCursorProviderModels),
+    grok: entry(getGrokProviderSettings, refreshGrokProviderModels, isGrokSetUp),
+    deepseek: entry(deepseekSettings, deepseekSettingsService?.refreshModels),
+  };
+}
+
+/**
+ * Refreshes the given providers (all by default) side by side. Returns
+ * `{ results: { <provider>: result }, changed }`: a provider that is off or
+ * has no refresh is skipped; a refresh that throws answers ok:false with the
+ * provider's current models. `changed` tells whether any provider's offered
+ * models changed or a refresh found models it had not seen before.
+ */
+export async function refreshProviderModels({
+  table = {},
+  providers = MODEL_REFRESH_PROVIDERS.map((provider) => provider.id),
+  reason = 'manual-refresh',
+  gate = 'isEnabled',
+} = {}) {
+  const ids = providers.filter((id) => table[id]);
+  const before = new Map(ids.map((id) => [id, JSON.stringify(table[id].currentModels?.() || [])]));
+  const settled = await Promise.allSettled(ids.map((id) => {
+    const entry = table[id];
+    const open = typeof entry?.[gate] === 'function' ? entry[gate]() : false;
+    if (!open || typeof entry.refresh !== 'function') return Promise.resolve({ ...SKIPPED });
+    return Promise.resolve().then(() => entry.refresh(reason));
+  }));
+  const results = {};
+  let changed = false;
+  ids.forEach((id, index) => {
+    const outcome = settled[index];
+    const label = modelRefreshProvider(id)?.label || id;
+    const result = outcome.status === 'fulfilled' && outcome.value && typeof outcome.value === 'object'
+      ? outcome.value
+      : {
+          ok: false,
+          models: table[id].currentModels?.() || [],
+          error: outcome.reason?.message || `${label} model discovery failed`,
+        };
+    results[id] = result;
+    if (result.skipped === true) return;
+    if (Array.isArray(result.newModels) && result.newModels.length) changed = true;
+    if (JSON.stringify(table[id].currentModels?.() || []) !== before.get(id)) changed = true;
+  });
+  return { results, changed };
+}