@oar-sh/oar 0.9.5 → 0.9.7

package/server/services/plan-usage-contract.mjs

@@ -9,9 +9,9 @@
  * while context usage describes one session's token window.
  *
  * Every provider normalizer in `plan-usage-<provider>.mjs` emits the same
- * `{ card: { meters, details, links } }` shape so the browser renderer stays
- * provider-agnostic, and so a provider that can only report *some* of its
- * limits degrades to fewer meters rather than to a special-cased layout.
+ * `{ card: { meters, details, notes, links } }` shape so the browser renderer
+ * stays provider-agnostic, and so a provider that can only report *some* of
+ * its limits degrades to fewer meters rather than to a special-cased layout.
  */
 
 export const PLAN_USAGE_VERSION = 2;
@@ -134,6 +134,16 @@ export function resolveMeterMath({
   };
 }
 
+/**
+ * A provider's severity word as a plain lowercase token ("normal",
+ * "warning", …). The vocabulary is the provider's; anything that is not a
+ * simple word is dropped rather than shown.
+ */
+export function toSeverity(value) {
+  const text = String(value ?? '').trim().toLowerCase();
+  return /^[a-z][a-z0-9_-]{0,23}$/.test(text) ? text : null;
+}
+
 /**
  * @param {object} spec
  * @param {string} spec.id            stable key, used by tests and DOM ids
@@ -141,6 +151,8 @@ export function resolveMeterMath({
  * @param {'credits'|'requests'|'usd'|'percent'|'tokens'} [spec.unit]
  * @param {boolean} [spec.unlimited]  plan grants unlimited use of this bucket
  * @param {boolean} [spec.estimated]  derived/manual rather than provider-authoritative
+ * @param {string} [spec.severity]    the provider's own word for how close the limit is
+ * @param {'expiry'} [spec.resetKind] `resetAt` is when the allowance ends for good, not when it refills
  * @returns {object|null} null when the meter carries no usable signal at all
  */
 export function buildMeter({
@@ -156,6 +168,8 @@ export function buildMeter({
   unlimited = false,
   estimated = false,
   emphasis = 'primary',
+  severity = null,
+  resetKind = null,
 } = {}) {
   const meterId = toTrimmedString(id);
   const meterLabel = toTrimmedString(label);
@@ -181,10 +195,29 @@ export function buildMeter({
     remaining: math.remaining,
     utilization: math.utilization,
     resetAt: toIsoTimestamp(resetAt),
+    resetKind: resetKind === 'expiry' ? 'expiry' : null,
+    severity: toSeverity(severity),
     note: toTrimmedString(note),
   };
 }
 
+/**
+ * A line of text on the card itself (not inside a collapsed section), with an
+ * optional link behind it. Same link rule as the card's footer: https only.
+ */
+export function buildCardNote({ id, text, link = null } = {}) {
+  const noteId = toTrimmedString(id);
+  const noteText = toTrimmedString(text);
+  if (!noteId || !noteText) return null;
+  const linkLabel = toTrimmedString(link?.label);
+  const url = toTrimmedString(link?.url);
+  return {
+    id: noteId,
+    text: noteText,
+    link: linkLabel && url && /^https:\/\//i.test(url) ? { label: linkLabel, url } : null,
+  };
+}
+
 /** A collapsible block of label/value rows shown under the meters. */
 export function buildDetailSection({ id, label, rows = [], note = null } = {}) {
   const sectionId = toTrimmedString(id);
@@ -214,6 +247,7 @@ export function buildProviderCard({
   stale = false,
   meters = [],
   details = [],
+  notes = [],
   links = [],
 } = {}) {
   const providerId = toTrimmedString(provider);
@@ -222,6 +256,7 @@ export function buildProviderCard({
 
   const normalizedMeters = (Array.isArray(meters) ? meters : []).filter(Boolean);
   const normalizedDetails = (Array.isArray(details) ? details : []).filter(Boolean);
+  const normalizedNotes = (Array.isArray(notes) ? notes : []).map((note) => buildCardNote(note || {})).filter(Boolean);
   const normalizedLinks = (Array.isArray(links) ? links : [])
     .map((link) => {
       const linkLabel = toTrimmedString(link?.label);
@@ -245,6 +280,7 @@ export function buildProviderCard({
     stale: stale === true,
     meters: normalizedMeters,
     details: normalizedDetails,
+    notes: normalizedNotes,
     links: normalizedLinks,
   };
 }

package/server/services/plan-usage-service.mjs

@@ -20,6 +20,7 @@ import {
 } from './plan-usage-contract.mjs';
 import { buildCopilotPlanCard } from './plan-usage-copilot.mjs';
 import { buildClaudePlanCard } from './plan-usage-claude.mjs';
+import { CLAUDE_CLOUD_PROVIDER_ID, buildClaudeCloudPlanCard } from './plan-usage-claude-cloud.mjs';
 import {
   CURSOR_POOLS,
   applyCursorUsageDelta,
@@ -383,6 +384,59 @@ export function createPlanUsageService({ db, now = () => new Date(), dbg = () =>
     return { cycle };
   }
 
+  // Claude Cloud conversations keep their reported cost on the runtime
+  // session row (migration 0007). That table is the relay's, not this
+  // service's, so the statements are prepared on first use, and only once
+  // the table and the column are there (an older database has neither).
+  let claudeCloudSpendStmts = null;
+  function claudeCloudSpendStatements() {
+    if (claudeCloudSpendStmts) return claudeCloudSpendStmts;
+    const columns = new Set(db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((column) => String(column.name)));
+    if (!columns.has('claude_cloud_cost_usd') || !columns.has('provider_type')) return null;
+    claudeCloudSpendStmts = {
+      totals: db.prepare(`
+        SELECT COUNT(*) AS conversation_count, COALESCE(SUM(claude_cloud_cost_usd), 0) AS total_usd
+        FROM runtime_sessions
+        WHERE LOWER(TRIM(provider_type)) = '${CLAUDE_CLOUD_PROVIDER_ID}'
+      `),
+      byConversation: db.prepare(`
+        SELECT claude_cloud_cost_usd AS cost_usd
+        FROM runtime_sessions
+        WHERE conversation_id = ? AND LOWER(TRIM(provider_type)) = '${CLAUDE_CLOUD_PROVIDER_ID}'
+      `),
+    };
+    return claudeCloudSpendStmts;
+  }
+
+  /**
+   * What the relay's cloud conversations have cost: the sum of the latest
+   * cost each one reported and how many there are, plus the cost of
+   * `conversationId` when that is a cloud conversation (`conversation` is
+   * null for any other). Only conversations that still exist count: a deleted
+   * one takes its row with it. There are no dates on these figures, so no
+   * per-day or per-week sum is offered. Null when the storage is not there.
+   */
+  function readClaudeCloudSpend({ conversationId = '' } = {}) {
+    try {
+      const statements = claudeCloudSpendStatements();
+      if (!statements) return null;
+      const totals = statements.totals.get();
+      const id = toTrimmedString(conversationId);
+      const row = id ? statements.byConversation.get(id) : null;
+      const cost = row ? Number(row.cost_usd) : null;
+      return {
+        totalUsd: Number(totals?.total_usd) || 0,
+        conversationCount: Number(totals?.conversation_count) || 0,
+        conversation: row
+          ? { costUsd: row.cost_usd !== null && Number.isFinite(cost) ? cost : null }
+          : null,
+      };
+    } catch (error) {
+      dbg('claude cloud spend read failed', error?.message || String(error));
+      return null;
+    }
+  }
+
   /**
    * Assemble the full multi-provider report. Every provider is independent:
    * one failing source produces an unavailable card instead of failing the
@@ -392,8 +446,17 @@ export function createPlanUsageService({ db, now = () => new Date(), dbg = () =>
     copilotSummary = null,
     copilotError = null,
     copilotStale = false,
+    // When the quota answer is an earlier one served again (the modal asked
+    // for another provider live), the time it was really read.
+    copilotCapturedAt = null,
     copilotBilling = null,
     claudeConfigured = true,
+    // Live account usage (claude-account-usage-service.mjs), or null: it is
+    // only ever read while Claude Cloud is switched on.
+    claudeAccount = null,
+    claudeCloudConfigured = false,
+    // The conversation the modal was opened from, for its own cloud cost.
+    conversationId = '',
     cursorConfigured = true,
     cursorAllowances = null,
     cursorBilling = null,
@@ -404,6 +467,9 @@ export function createPlanUsageService({ db, now = () => new Date(), dbg = () =>
   } = {}) {
     const generatedAt = nowIso();
     const claudeSnapshot = readSnapshot('claude');
+    // What the cloud workers post to /api/claude-plan-usage is kept under its
+    // own key, so the Claude card stays what the Claude workers wrote.
+    const claudeCloudSnapshot = claudeCloudConfigured === true ? readSnapshot(CLAUDE_CLOUD_PROVIDER_ID) : null;
     const allowances = normalizeCursorAllowanceSettings(cursorAllowances || {});
     const cursorCycle = readCursorCycleTotals({ resetDay: allowances.resetDay });
     const grokSettings = normalizeGrokAllowanceSettings(grokAllowances || {});
@@ -421,7 +487,7 @@ export function createPlanUsageService({ db, now = () => new Date(), dbg = () =>
         billing: copilotBilling,
         workerUsage: copilotWorkerSnapshot?.payload || null,
         error: copilotError,
-        capturedAt: generatedAt,
+        capturedAt: copilotCapturedAt || generatedAt,
         stale: copilotStale === true,
       }),
       buildClaudePlanCard({
@@ -431,9 +497,22 @@ export function createPlanUsageService({ db, now = () => new Date(), dbg = () =>
         message: claudeSnapshot?.error || null,
         // A stored snapshot is by definition from an earlier turn; the SDK's
         // usage control call only works while a session transport is open, and
-        // the relay never opens a billable turn just to refresh this.
+        // the relay never opens a billable turn just to refresh this. Live
+        // account usage, where there is any, takes the meters over.
         stale: !!claudeSnapshot?.payload,
+        account: claudeAccount,
       }),
+      // Opt-in like Grok (no card while the provider is off), and placed next
+      // to the Claude card because both are the same account.
+      claudeCloudConfigured === true
+        ? buildClaudeCloudPlanCard({
+          account: claudeAccount,
+          spend: readClaudeCloudSpend({ conversationId }),
+          usage: claudeCloudSnapshot?.payload || null,
+          capturedAt: claudeCloudSnapshot?.capturedAt || null,
+          configured: true,
+        })
+        : null,
       buildCursorPlanCard({
         totals: cursorCycle.totals,
         allowances,
@@ -481,6 +560,7 @@ export function createPlanUsageService({ db, now = () => new Date(), dbg = () =>
     recordGrokUsageReport,
     readGrokCycleTotals,
     resetGrokAccounting,
+    readClaudeCloudSpend,
     buildReport,
     pools: CURSOR_POOLS,
   };

package/server/services/preview-proxy-server.mjs

@@ -239,6 +239,11 @@ function guardConnectTimeout(upstreamReq, timeoutMs, onTimeout) {
   });
 }
 
+// Requests the lane sends a second time when the connection it kept to the
+// dev server turns out to be closed, and what such a connection fails with.
+const REPEATABLE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+const STALE_CONNECTION_CODES = new Set(['ECONNRESET', 'EPIPE']);
+
 export function createPreviewProxyServer({
   registry,
   logger = console,
@@ -327,46 +332,69 @@ export function createPreviewProxyServer({
       bearerTokens: relayBearerTokens,
     });
 
-    const upstreamReq = httpImpl.request({
-      host: entry.targetHost,
-      port: entry.targetPort,
-      method: req.method,
-      path: upstreamPath,
-      headers,
-      agent,
-    });
-
-    let timedOut = false;
-    guardConnectTimeout(upstreamReq, connectTimeoutMs, () => { timedOut = true; });
+    // A request without a body can be sent a second time.
+    const repeatable = REPEATABLE_METHODS.has(String(req.method || '').toUpperCase())
+      && !(Number(req.headers['content-length']) > 0)
+      && !req.headers['transfer-encoding'];
+    let upstreamReq = null;
+
+    const forward = ({ again = false } = {}) => {
+      const current = httpImpl.request({
+        host: entry.targetHost,
+        port: entry.targetPort,
+        method: req.method,
+        path: upstreamPath,
+        headers,
+        agent,
+      });
+      upstreamReq = current;
+
+      let timedOut = false;
+      guardConnectTimeout(current, connectTimeoutMs, () => { timedOut = true; });
+
+      current.on('response', (upstreamRes) => {
+        const outHeaders = sanitizeResponseHeaders(upstreamRes.headers, {
+          basePath: entry.basePath,
+          targetHost: entry.targetHost,
+          targetPort: entry.targetPort,
+        });
+        res.writeHead(upstreamRes.statusCode || 502, outHeaders);
+        // 204/304 and HEAD carry no body; piping one would desync the connection.
+        if (req.method === 'HEAD' || upstreamRes.statusCode === 204 || upstreamRes.statusCode === 304) {
+          upstreamRes.resume();
+          res.end();
+          return;
+        }
+        upstreamRes.pipe(res);
+        upstreamRes.on('error', () => { try { res.destroy(); } catch {} });
+      });
 
-    upstreamReq.on('response', (upstreamRes) => {
-      const outHeaders = sanitizeResponseHeaders(upstreamRes.headers, {
-        basePath: entry.basePath,
-        targetHost: entry.targetHost,
-        targetPort: entry.targetPort,
+      current.on('error', (error) => {
+        if (upstreamReq !== current) return;
+        // The connection was kept from an earlier request, and the dev server
+        // has closed it since (it exited, or was restarted): that says nothing
+        // about the server now. One more try on a connection of its own either
+        // reaches the restarted server or says that nothing is listening.
+        if (!again && repeatable && current.reusedSocket && !res.headersSent && !res.destroyed
+          && STALE_CONNECTION_CODES.has(String(error?.code || ''))) {
+          forward({ again: true });
+          return;
+        }
+        const refused = String(error?.code || '') === 'ECONNREFUSED';
+        const detail = refused || timedOut
+          ? `Nothing is listening on <code>${escapeHtml(entry.targetHost)}:${entry.targetPort}</code>. The dev server behind this preview has probably exited — restart it on the same port and reload; this link stays valid.`
+          : `The upstream connection failed: <code>${escapeHtml(error?.code || error?.message || 'unknown error')}</code>.`;
+        sendErrorPage(res, 502, { title: 'Preview upstream unreachable', detail });
       });
-      res.writeHead(upstreamRes.statusCode || 502, outHeaders);
-      // 204/304 and HEAD carry no body; piping one would desync the connection.
-      if (req.method === 'HEAD' || upstreamRes.statusCode === 204 || upstreamRes.statusCode === 304) {
-        upstreamRes.resume();
-        res.end();
-        return;
-      }
-      upstreamRes.pipe(res);
-      upstreamRes.on('error', () => { try { res.destroy(); } catch {} });
-    });
 
-    upstreamReq.on('error', (error) => {
-      const refused = String(error?.code || '') === 'ECONNREFUSED';
-      const detail = refused || timedOut
-        ? `Nothing is listening on <code>${escapeHtml(entry.targetHost)}:${entry.targetPort}</code>. The dev server behind this preview has probably exited — restart it on the same port and reload; this link stays valid.`
-        : `The upstream connection failed: <code>${escapeHtml(error?.code || error?.message || 'unknown error')}</code>.`;
-      sendErrorPage(res, 502, { title: 'Preview upstream unreachable', detail });
-    });
+      // The second try has nothing left to read from the request.
+      if (again) current.end();
+      else req.pipe(current);
+    };
 
-    req.on('aborted', () => { try { upstreamReq.destroy(); } catch {} });
-    res.on('close', () => { try { upstreamReq.destroy(); } catch {} });
-    req.pipe(upstreamReq);
+    req.on('aborted', () => { try { upstreamReq?.destroy(); } catch {} });
+    res.on('close', () => { try { upstreamReq?.destroy(); } catch {} });
+    forward();
   }
 
   // WebSocket upgrades (Vite HMR, an app's own socket) ride the same prefix.

package/server/services/process-list-service.mjs

@@ -0,0 +1,122 @@
+'use strict';
+
+// The process table, read the way each platform allows, for the tree watch in
+// shared/worker-runtime/process-tree.mjs. Every entry carries the time the
+// process was started: that is what tells it from a later process that was
+// given its pid.
+//
+//  - Linux reads `/proc/<pid>/stat`, which needs no process and takes about
+//    3 ms for 160 processes (measured 2026-09-29). The start time is field 22,
+//    in clock ticks since boot.
+//  - Windows asks PowerShell, through the list the relay's process inspector
+//    already reads. It takes about a second, so it is never polled.
+//  - Every other platform asks `ps`, whose start time has a resolution of one
+//    second.
+
+import fs from 'fs';
+import { execFile } from 'child_process';
+
+import { createSessionWorkerProcessInspector } from './session-worker-process-service.mjs';
+
+const PS_TIMEOUT_MS = 10_000;
+
+/**
+ * One `/proc/<pid>/stat`. The name (field 2) is in parentheses and may hold
+ * spaces and parentheses of its own, so the fields after it are counted from
+ * the LAST closing one. A process that has ended and only waits to be
+ * collected (`Z`, `X`) is not running any more.
+ */
+export function parseProcStat(text) {
+  const raw = String(text || '');
+  const open = raw.indexOf('(');
+  const close = raw.lastIndexOf(')');
+  if (open < 1 || close < open) return null;
+  const processId = Number.parseInt(raw.slice(0, open), 10);
+  const fields = raw.slice(close + 2).trim().split(/\s+/);
+  const state = fields[0] || '';
+  const createdAt = Number(fields[19]);
+  if (!(processId > 0) || state === 'Z' || state === 'X' || !(createdAt > 0)) return null;
+  return {
+    processId,
+    parentProcessId: Number.parseInt(fields[1], 10) || 0,
+    name: raw.slice(open + 1, close),
+    createdAt,
+    // The runtime starts a command in a session of its own.
+    sessionLeader: Number.parseInt(fields[3], 10) === processId,
+  };
+}
+
+/** One line of `ps -o pid=,ppid=,stat=,lstart=,args=`. */
+export function parsePsLine(line) {
+  const match = String(line || '').match(
+    /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\w{3}\s+\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s*(.*)$/,
+  );
+  if (!match) return null;
+  const createdAt = Date.parse(match[4]);
+  if (/^[ZX]/.test(match[3]) || !(createdAt > 0)) return null;
+  return {
+    processId: Number.parseInt(match[1], 10),
+    parentProcessId: Number.parseInt(match[2], 10) || 0,
+    createdAt,
+    commandLine: match[5],
+  };
+}
+
+export function createProcessLister({
+  platform = process.platform,
+  readdirSyncImpl = fs.readdirSync,
+  readFileSyncImpl = fs.readFileSync,
+  execFileImpl = execFile,
+  inspector = null,
+} = {}) {
+  if (platform === 'win32') {
+    const windows = inspector || createSessionWorkerProcessInspector({ platform, execFileImpl });
+    return {
+      // A child keeps the pid of its parent after the parent has ended.
+      orphansKeepParent: true,
+      list: () => windows.readWindowsProcessSnapshot(),
+    };
+  }
+
+  if (platform === 'linux') {
+    const read = (pid) => {
+      try {
+        return parseProcStat(readFileSyncImpl(`/proc/${pid}/stat`, 'utf8'));
+      } catch {
+        // It ended between the directory listing and the read.
+        return null;
+      }
+    };
+    return {
+      orphansKeepParent: false,
+      list: () => readdirSyncImpl('/proc')
+        .filter((name) => /^\d+$/.test(String(name)))
+        .map((name) => read(name))
+        .filter(Boolean),
+      read,
+      describe(pid) {
+        try {
+          return String(readFileSyncImpl(`/proc/${pid}/cmdline`, 'utf8')).replace(/\0/g, ' ').trim();
+        } catch {
+          return '';
+        }
+      },
+    };
+  }
+
+  return {
+    orphansKeepParent: false,
+    list: () => new Promise((resolve, reject) => {
+      execFileImpl(
+        'ps',
+        ['-axww', '-o', 'pid=,ppid=,stat=,lstart=,args='],
+        // `lstart` is parsed as a date: keep it in the one language that is.
+        { timeout: PS_TIMEOUT_MS, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' } },
+        (error, stdout) => {
+          if (error) reject(error);
+          else resolve(String(stdout || '').split(/\r?\n/).map(parsePsLine).filter(Boolean));
+        },
+      );
+    }),
+  };
+}

package/server/services/provider-reasoning-effort.mjs

@@ -12,6 +12,7 @@ import { openAIReasoningEffortsForModel } from '../../shared/openai-reasoning.mj
 export const CLAUDE_ULTRACODE_EFFORT = 'ultracode';
 export const DEFAULT_CLAUDE_REASONING_EFFORTS = Object.freeze(['none', 'low', 'medium', 'high', 'xhigh', 'max', CLAUDE_ULTRACODE_EFFORT]);
 export const DEFAULT_GROK_REASONING_EFFORTS = Object.freeze(['none', 'low', 'medium', 'high']);
+export const CLAUDE_CLOUD_REASONING_EFFORTS = Object.freeze(['none']);
 
 // Ultracode requires an xhigh-capable model (the SDK's stated gate), so the
 // tier is derived from a model's discovered efforts rather than discovery —
@@ -54,6 +55,8 @@ export function supportedReasoningEffortsForProviderModel({
   if (provider === 'grok') {
     return effortsForModel(grokSettings?.effortsByModel, model) || [...DEFAULT_GROK_REASONING_EFFORTS];
   }
+  // A cloud session takes no effort choice: the only tier is the default one.
+  if (provider === 'claude-cloud') return [...CLAUDE_CLOUD_REASONING_EFFORTS];
   if (provider === 'openai' || provider === 'openai-image') {
     const efforts = openAIReasoningEffortsForModel(model);
     return Array.isArray(efforts) && efforts.length ? efforts.map(normalizeEffort).filter(Boolean) : null;