@oar-sh/oar 0.9.19 → 0.9.21

package/server/services/about-service.mjs

@@ -3,6 +3,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { normalizeBuildId, readGitCommit, resolveBuildCommit } from '../../shared/build-id.mjs';
+import { isWorkerOnOtherBuild } from './worker-recycle-service.mjs';
+
+// The commit readers moved to shared/ so the workers can state their build id
+// too; they are re-exported here so the routes and tests importing them keep
+// their import.
+export { readGitCommit, resolveBuildCommit };
+
 // What the About OAR modal shows: the running build, the providers that are
 // on, what this relay has stored over its life, and how it is doing now.
 //
@@ -64,58 +72,6 @@ function readFileText(fsImpl, filePath) {
   }
 }
 
-const COMMIT_PATTERN = /^[0-9a-f]{40}$/i;
-
-/**
- * The commit a git checkout has checked out, read from its .git files rather
- * than from a `git` process: HEAD, then the loose ref, then packed-refs. A
- * linked worktree's .git is a file naming its git dir, whose refs live in the
- * common dir. Anything unexpected reads as null. `pathImpl` is the host's path
- * module; tests pass path.posix and path.win32.
- */
-export function readGitCommit(root, { fsImpl = fs, pathImpl = path } = {}) {
-  if (!root) return null;
-  const dotGit = pathImpl.join(root, '.git');
-  let gitDir = dotGit;
-  const pointer = readFileText(fsImpl, dotGit);
-  if (pointer !== null) {
-    const match = pointer.match(/^gitdir:\s*(.+)$/m);
-    if (!match) return null;
-    gitDir = pathImpl.resolve(root, match[1].trim());
-  }
-  const head = readFileText(fsImpl, pathImpl.join(gitDir, 'HEAD'));
-  if (head === null) return null;
-  const headText = head.trim();
-  if (COMMIT_PATTERN.test(headText)) return headText.toLowerCase();
-  const refMatch = headText.match(/^ref:\s*(\S+)$/);
-  if (!refMatch) return null;
-  const ref = refMatch[1];
-  const commonDirText = readFileText(fsImpl, pathImpl.join(gitDir, 'commondir'));
-  const commonDir = commonDirText ? pathImpl.resolve(gitDir, commonDirText.trim()) : gitDir;
-  for (const dir of new Set([gitDir, commonDir])) {
-    const loose = readFileText(fsImpl, pathImpl.join(dir, ...ref.split('/')));
-    if (loose && COMMIT_PATTERN.test(loose.trim())) return loose.trim().toLowerCase();
-  }
-  const packed = readFileText(fsImpl, pathImpl.join(commonDir, 'packed-refs')) || '';
-  for (const line of packed.split(/\r?\n/)) {
-    const [hash, name] = line.trim().split(/\s+/);
-    if (name === ref && COMMIT_PATTERN.test(hash || '')) return hash.toLowerCase();
-  }
-  return null;
-}
-
-/** The commit this build came from: the checkout's HEAD, else a `gitHead` stamp in package.json. */
-export function resolveBuildCommit(packageRoot, { fsImpl = fs, pathImpl = path } = {}) {
-  const fromGit = readGitCommit(packageRoot, { fsImpl, pathImpl });
-  if (fromGit) return fromGit;
-  try {
-    const stamp = String(JSON.parse(readFileText(fsImpl, pathImpl.join(packageRoot, 'package.json')) || '{}')?.gitHead || '').trim();
-    return COMMIT_PATTERN.test(stamp) ? stamp.toLowerCase() : null;
-  } catch {
-    return null;
-  }
-}
-
 export function readInstalledPackageVersion(packageRoot, packageName, { fsImpl = fs } = {}) {
   if (!packageRoot || !packageName) return null;
   try {
@@ -273,6 +229,42 @@ export function collectUsageTotals(db) {
       usage['claude-cloud'] = { costUsd: toAmount(row.cost), sessions: toCount(row.sessions) };
     }
   }
+  // Every provider's tokens per turn, all time (token_usage_days, migration
+  // 0036): fresh input, output, cache writes and cache reads apart, each
+  // null while no turn reported it, the first day, and whether days copied
+  // at the upgrade are in it. An own key's turns (Copilot) are kept apart
+  // from the plan's.
+  if (tableExists(db, 'token_usage_days')) {
+    const rows = db.prepare(`
+      SELECT provider, billing, SUM(input_tokens) AS input, SUM(output_tokens) AS output,
+             SUM(cache_write_tokens) AS cache_write, SUM(cache_read_tokens) AS cache_read, MIN(day) AS since,
+             MIN(CASE WHEN source = 'turns' THEN day END) AS first_turns_day,
+             MAX(CASE WHEN source = 'backfill' THEN 1 ELSE 0 END) AS backfilled
+      FROM token_usage_days
+      GROUP BY provider, billing
+      ORDER BY provider, billing
+    `).all();
+    const nullable = (value) => (value === null || value === undefined ? null : toAmount(value));
+    for (const row of rows) {
+      const tokens = {
+        inputTokens: nullable(row.input),
+        outputTokens: nullable(row.output),
+        cacheWriteTokens: nullable(row.cache_write),
+        cacheReadTokens: nullable(row.cache_read),
+        since: row.since || null,
+        // Days copied at the upgrade (0036) hold cache writes inside input;
+        // the first counted turn's day is where that stops.
+        backfilled: Number(row.backfilled) === 1,
+        firstTurnsDay: row.first_turns_day || null,
+      };
+      const entry = usage[row.provider] || (usage[row.provider] = {});
+      if (row.billing) {
+        (entry.ownKeyTokens || (entry.ownKeyTokens = [])).push({ billing: row.billing, ...tokens });
+      } else {
+        entry.tokens = tokens;
+      }
+    }
+  }
   return usage;
 }
 
@@ -302,6 +294,7 @@ async function fileSize(fsImpl, filePath) {
  * @param {string|null} [deps.dbPath] the database file; its -wal file is counted too
  * @param {string} deps.version
  * @param {string|null} [deps.commit]
+ * @param {string|null} [deps.buildId] the relay's build id (shared/build-id.mjs), to tell the workers on other code
  * @param {string} [deps.installMethod]
  * @param {string} deps.startedAt ISO time this relay process started
  * @param {() => object} [deps.getProviderSettings] `{ github: { enabled, engine }, claude: { enabled }, … }`
@@ -310,12 +303,15 @@ async function fileSize(fsImpl, filePath) {
  * @param {() => object[]} [deps.listWorkers] the session worker registry's entries
  * @param {() => object|null} [deps.getUpdateState] buildUpdateStatePayload()
  * @param {object} [deps.sdkVersions] package version by provider id; read from node_modules when absent
+ * @param {() => object|null} [deps.describeBackups] the database backups (db-backup-service.mjs describeBackups)
  */
 export function createAboutService({
   db,
   dbPath = null,
+  describeBackups = null,
   version = '0.0.0',
   commit = null,
+  buildId = null,
   installMethod = null,
   startedAt,
   packageRoot = null,
@@ -359,20 +355,30 @@ export function createAboutService({
     return totalsInFlight;
   }
 
+  // The running workers, by provider and by build: after a deploy the
+  // workers keep the code they started with until the recycle replaces them,
+  // and About shows how many still do. A relay that does not know its own
+  // build id cannot tell, so both build counts are null then.
   function runningWorkersByProvider() {
     const counts = new Map();
     let total = 0;
+    const relayBuildId = normalizeBuildId(buildId);
+    let onOtherBuild = 0;
     for (const worker of listWorkers() || []) {
       const status = String(worker?.status || '').trim().toLowerCase();
       if (!ACTIVE_WORKER_STATUSES.has(status) || !isPidAlive(worker?.pid)) continue;
       total += 1;
+      if (isWorkerOnOtherBuild(worker, relayBuildId)) onOtherBuild += 1;
       const conversationId = String(worker?.conversationId || '').trim();
       const provider = conversationId
         ? normalizeProviderId(providerForConversation.get(conversationId)?.provider_type)
         : 'unassigned';
       counts.set(provider, (counts.get(provider) || 0) + 1);
     }
-    return { total, counts };
+    const builds = relayBuildId
+      ? { total, onThisBuild: total - onOtherBuild, onOtherBuild }
+      : { total, onThisBuild: null, onOtherBuild: null };
+    return { total, counts, builds };
   }
 
   function describeProviders(workerCounts) {
@@ -436,6 +442,7 @@ export function createAboutService({
       startedAt: startedAt || null,
       uptimeSeconds,
       providers: describeProviders(workers.counts),
+      workers: workers.builds,
       stats: {
         conversations: totals.conversations.total,
         archivedConversations: totals.conversations.archived,
@@ -451,14 +458,35 @@ export function createAboutService({
       usage: totals.usage,
       relay: {
         uptimeSeconds,
+        // The full path: which of the two database names this relay runs on.
+        dbPath: dbPath || null,
         dbBytes: dbFileBytes + walBytes,
         dbFileBytes,
         walBytes,
         runningWorkers: workers.total,
       },
       update: describeUpdate(),
+      backups: readBackups(),
     };
   }
 
+  // The last backup and how many are kept, for one row; never the listing.
+  function readBackups() {
+    if (!describeBackups) return null;
+    try {
+      const backups = describeBackups();
+      return {
+        enabled: backups.enabled,
+        keep: backups.keep,
+        dir: backups.dir,
+        problem: backups.problem,
+        kept: backups.own.length,
+        lastResult: backups.lastResult,
+      };
+    } catch {
+      return null;
+    }
+  }
+
   return { describe };
 }

package/server/services/cache-rebuild-service.mjs

@@ -1,5 +1,7 @@
 'use strict';
 
+import { forgetTurnTokenRows } from './token-usage-service.mjs';
+
 function normalizeId(value) {
   return String(value || '').trim();
 }
@@ -99,6 +101,8 @@ export function createCacheRebuildService({
       db.prepare(`DELETE FROM queue WHERE conversation_id = ?`).run(sid);
       db.prepare(`DELETE FROM messages WHERE conversation_id = ?`).run(sid);
       db.prepare(`DELETE FROM runtime_sessions WHERE conversation_id = ?`).run(sid);
+      // Its turns' tokens go too; the day sums stay.
+      forgetTurnTokenRows(db, [sid]);
       db.prepare(`DELETE FROM conversations WHERE id = ?`).run(sid);
     })();
     closePreviews(sid);
@@ -164,6 +168,9 @@ export function createCacheRebuildService({
       db.prepare(`DELETE FROM queue`).run();
       db.prepare(`DELETE FROM messages`).run();
       db.prepare(`DELETE FROM runtime_sessions`).run();
+      // The turn tokens of the chats removed for good; a hand-titled chat
+      // stays, and keeps them.
+      forgetTurnTokenRows(db, db.prepare(`SELECT id FROM conversations WHERE status = 'deleted' OR title_source != 'manual'`).all().map((row) => row.id));
       db.prepare(`DELETE FROM conversations WHERE status = 'deleted' OR title_source != 'manual'`).run();
       for (const conversationId of manualTitleConversations) {
         db.prepare(`

package/server/services/claude-billing-swap-service.mjs

@@ -28,29 +28,16 @@
  * the fence lets them through, and the waiting state ages out.
  */
 
+import { workerReleaseHold } from './worker-replacement.mjs';
+
 export const CLAUDE_BILLING_SWAP_WAIT_TTL_MS = 15_000;
 
 /**
- * What keeps a worker from being replaced now: null when nothing does, else
- * 'turn', 'question', 'compaction' or 'background'. From the steering
- * snapshot its heartbeat sends; a worker too old to say `releasable` is read
- * from the rest of it.
+ * What keeps a worker from being replaced now (worker-replacement.mjs, which
+ * the worker recycle shares). Kept under its old name for the importers that
+ * know it by that.
  */
-export function claudeWorkerReleaseHold(worker) {
-  if (!worker) return null;
-  const steering = worker.steering || null;
-  if (steering && typeof steering.releasable === 'boolean') {
-    return steering.releasable ? null : (steering.releaseHold || 'turn');
-  }
-  if (steering) {
-    if (steering.holdReason === 'question') return 'question';
-    if (steering.holdReason === 'compaction') return 'compaction';
-    if (steering.turnActive) return 'turn';
-    if (steering.autoCompactWindow?.backgroundWork) return 'background';
-    return null;
-  }
-  return String(worker.status || '') === 'processing' ? 'turn' : null;
-}
+export const claudeWorkerReleaseHold = workerReleaseHold;
 
 export function createClaudeBillingSwapService({
   // sid → the registry's entry for the session's worker, or null.
@@ -208,7 +195,7 @@ export function createClaudeBillingSwapService({
       running = true;
       noteProbeFailure(sid, state, fence, error);
     }
-    const hold = running ? 'turn' : claudeWorkerReleaseHold(worker);
+    const hold = running ? 'turn' : workerReleaseHold(worker);
     if (hold) {
       setPending(sid, state, {
         to: fence.rowBilling,

package/server/services/claude-cloud-session-service.mjs

@@ -157,12 +157,9 @@ export function buildClaudeCloudDelivery({ conversation = null, runtimeSession =
   if (!isClaudeCloudProviderType(runtimeSession?.provider_type)) return null;
   const source = parseCloudSourceJson(conversation?.cloud_source_json);
   if (!source) return null;
-  const sessionId = toText(runtimeSession?.claude_cloud_session_id);
-  const lastSequence = toText(runtimeSession?.claude_cloud_last_sequence);
   const fallback = toText(fallbackEnvironmentId);
   return {
-    sessionId: isSafeClaudeCloudId(sessionId) ? sessionId : null,
-    lastSequence: SEQUENCE_PATTERN.test(lastSequence) ? lastSequence : null,
+    ...readStoredClaudeCloudBinding(runtimeSession),
     repoUrl: source.repoUrl,
     branch: source.branch,
     environmentId: source.environmentId || (isSafeClaudeCloudId(fallback) ? fallback : null),
@@ -170,6 +167,20 @@ export function buildClaudeCloudDelivery({ conversation = null, runtimeSession =
   };
 }
 
+/**
+ * The cloud session a runtime session row is bound to and the cursor its
+ * worker reads on from: `{ sessionId, lastSequence }`, each null when absent
+ * or not in the shape the worker may put into a request path.
+ */
+export function readStoredClaudeCloudBinding(runtimeSession = null) {
+  const sessionId = toText(runtimeSession?.claude_cloud_session_id);
+  const lastSequence = toText(runtimeSession?.claude_cloud_last_sequence);
+  return {
+    sessionId: isSafeClaudeCloudId(sessionId) ? sessionId : null,
+    lastSequence: SEQUENCE_PATTERN.test(lastSequence) ? lastSequence : null,
+  };
+}
+
 /** The larger of two sequence numbers (strings of digits), so a late report never moves the cursor back. */
 function laterSequence(stored, reported) {
   const a = SEQUENCE_PATTERN.test(toText(stored)) ? toText(stored) : null;
@@ -264,6 +275,31 @@ export function createClaudeCloudSessionService({
     return { ok: true, cloud };
   }
 
+  /**
+   * GET /api/claude-cloud-session: the binding a starting worker attaches to
+   * before any delivery (so it follows the turns the session starts by
+   * itself, as the worker it replaces did). `id` is the conversation id or
+   * the runtime session's sdk session id, which is all a worker knows of its
+   * conversation. A known conversation that has no cloud session (none yet,
+   * or another provider) answers `sessionId: null`; only an unknown id is
+   * 404. Returns `{ ok, statusCode, error }` or `{ ok: true, sessionId,
+   * lastSequence }`.
+   */
+  function describeStoredBinding(id = '') {
+    const key = toText(id);
+    if (!key) return { ok: false, statusCode: 400, error: 'Missing conversationId' };
+    const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(key)
+      || stmts.getRuntimeSessionBySdkSessionId?.get?.(key)
+      || null;
+    if (!runtimeSession && !stmts.getConvAnyStatus?.get?.(key)) {
+      return { ok: false, statusCode: 404, error: 'Conversation not found' };
+    }
+    if (!runtimeSession || !isClaudeCloudProviderType(runtimeSession.provider_type)) {
+      return { ok: true, sessionId: null, lastSequence: null };
+    }
+    return { ok: true, ...readStoredClaudeCloudBinding(runtimeSession) };
+  }
+
   /**
    * Archives the cloud session of a conversation that is being deleted or
    * archived here. Best effort: it returns at once (true when an archive was
@@ -322,5 +358,11 @@ export function createClaudeCloudSessionService({
     return true;
   }
 
-  return { cloudPayloadFor, recordWorkerReport, archiveSessionInBackground, unarchiveSessionInBackground };
+  return {
+    cloudPayloadFor,
+    recordWorkerReport,
+    describeStoredBinding,
+    archiveSessionInBackground,
+    unarchiveSessionInBackground,
+  };
 }

package/server/services/conversation-preferences-service.mjs

@@ -44,6 +44,9 @@ export function persistConversationPreferences({
   // The owner's "agents in this conversation may start sessions" (a boolean;
   // `undefined` leaves it alone). The route decides who may write it.
   mayCreateSessions = undefined,
+  // Plan-only: agents cannot take the session out of plan mode (a boolean;
+  // `undefined` leaves it alone). The routes decide who may write it.
+  planOnly = undefined,
   updatedAt = new Date().toISOString(),
   createIfMissing = false,
   createTitle = 'Session',
@@ -60,6 +63,7 @@ export function persistConversationPreferences({
   const writesThinkingDisplay = thinkingDisplay !== undefined;
   const display = writesThinkingDisplay ? parseThinkingDisplay(thinkingDisplay) : null;
   const writesMayCreateSessions = mayCreateSessions !== undefined;
+  const writesPlanOnly = planOnly !== undefined;
   if (!db || !stmts || !convId || !mode) {
     return {
       ok: false,
@@ -71,6 +75,7 @@ export function persistConversationPreferences({
       thinkingEnabled: DEFAULT_THINKING_ENABLED,
       thinkingDisplay: DEFAULT_THINKING_DISPLAY,
       mayCreateSessions: false,
+      planOnly: false,
       updatedAt,
     };
   }
@@ -108,6 +113,10 @@ export function persistConversationPreferences({
       extraSets.push('may_create_sessions = ?');
       extraValues.push(mayCreateSessions === true ? 1 : 0);
     }
+    if (writesPlanOnly) {
+      extraSets.push('plan_only = ?');
+      extraValues.push(planOnly === true ? 1 : 0);
+    }
     try {
       if (extraSets.length) {
         db.prepare(`
@@ -148,6 +157,9 @@ export function persistConversationPreferences({
       mayCreateSessions: writesMayCreateSessions
         ? mayCreateSessions === true
         : readMayCreateSessions(existing),
+      planOnly: writesPlanOnly
+        ? planOnly === true
+        : readPlanOnly(existing),
       updatedAt,
     };
   });
@@ -159,6 +171,25 @@ export function readMayCreateSessions(row) {
   return Number(row?.may_create_sessions) === 1;
 }
 
+/** Whether a conversations row is plan-only (migration 0035; NULL is not). */
+export function readPlanOnly(row) {
+  return Number(row?.plan_only) === 1;
+}
+
+/**
+ * A compaction's new conversation keeps a plan-only source's lock and the
+ * mode it is saved in, so the work goes on as locked as it was. Nothing for
+ * any other source. Returns whether it carried the lock.
+ */
+export function carryPlanOnlyToCompacted({ db, stmts, source, targetConversationId, updatedAt = new Date().toISOString() } = {}) {
+  if (!db || !stmts?.conversationsHavePlanOnly || !readPlanOnly(source)) return false;
+  const target = String(targetConversationId || '').trim();
+  if (!target) return false;
+  const mode = String(source?.preferred_relay_mode || '').trim() || 'plan';
+  db.prepare(`UPDATE conversations SET plan_only = 1, preferred_relay_mode = ?, updated_at = ? WHERE id = ?`).run(mode, updatedAt, target);
+  return true;
+}
+
 export function persistConversationModelPreference({
   db,
   stmts,