@oar-sh/oar 0.9.16 → 0.9.18

package/server/migrations/0034-claude-api-usage-totals.mjs

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * Migration: Claude API usage totals (services/plan-usage-service.mjs, the
+ * Claude API card in Check Usage and its monthly cap).
+ *
+ * `claude_api_usage_totals`: what this relay's turns on the saved Claude API
+ * key ran, per day and model; a row only ever grows. Subscription turns are
+ * never booked here. The card shows today and this month, and the cap is a
+ * calendar month in relay local time, so the day is the relay's local date.
+ *
+ * - `day`: `YYYY-MM-DD`, the relay's local date of the turn's result.
+ * - `model`: the model's id as the CLI reported it, without the `[1m]`
+ *   suffix, lower case.
+ * - `hit_tokens`, `miss_tokens`, `output_tokens`: input read from the
+ *   prompt cache, other input (cache writes included), and output.
+ * - `cost_usd`: Claude Code's own estimate (`modelUsage[*].costUSD`) of what
+ *   the booked turns cost, for the turns it could price.
+ * - `unknown_cost_tokens`: the tokens of turns it could not price
+ *   (`costBasis: unknown`), which `cost_usd` leaves out.
+ * - `turn_count`: the posts that booked something for the model.
+ * - `first_seen_at`, `last_seen_at`, `updated_at`.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0034-claude-api-usage-totals.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const CLAUDE_API_USAGE_TOTALS_TABLE = 'claude_api_usage_totals';
+
+export const CLAUDE_API_USAGE_TOTALS_COLUMNS = Object.freeze([
+  'day',
+  'model',
+  'hit_tokens',
+  'miss_tokens',
+  'output_tokens',
+  'cost_usd',
+  'unknown_cost_tokens',
+  'turn_count',
+  'first_seen_at',
+  'last_seen_at',
+  'updated_at',
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+/** What keeps the service from using the table: '' when nothing does. */
+export function claudeApiUsageTotalsProblem(db) {
+  if (!tableExists(db, CLAUDE_API_USAGE_TOTALS_TABLE)) return `no ${CLAUDE_API_USAGE_TOTALS_TABLE} table`;
+  const present = new Set(db.prepare(`PRAGMA table_info(${CLAUDE_API_USAGE_TOTALS_TABLE})`).all().map((column) => column.name));
+  const missing = CLAUDE_API_USAGE_TOTALS_COLUMNS.filter((name) => !present.has(name));
+  if (missing.length) return `${CLAUDE_API_USAGE_TOTALS_TABLE} lacks ${missing.join(', ')}`;
+  return '';
+}
+
+export function migrateClaudeApiUsageTotals(db) {
+  if (tableExists(db, CLAUDE_API_USAGE_TOTALS_TABLE)) return { applied: false, tablesAdded: 0 };
+  db.exec(`
+    CREATE TABLE ${CLAUDE_API_USAGE_TOTALS_TABLE} (
+      day                  TEXT NOT NULL,
+      model                TEXT NOT NULL,
+      hit_tokens           INTEGER NOT NULL DEFAULT 0,
+      miss_tokens          INTEGER NOT NULL DEFAULT 0,
+      output_tokens        INTEGER NOT NULL DEFAULT 0,
+      cost_usd             REAL NOT NULL DEFAULT 0,
+      unknown_cost_tokens  INTEGER NOT NULL DEFAULT 0,
+      turn_count           INTEGER NOT NULL DEFAULT 0,
+      first_seen_at        TEXT NOT NULL,
+      last_seen_at         TEXT NOT NULL,
+      updated_at           TEXT NOT NULL,
+      PRIMARY KEY (day, model)
+    )
+  `);
+  return { applied: true, tablesAdded: 1 };
+}
+
+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 migrateClaudeApiUsageTotals(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 0034 on ${dbPath}`);
+    console.log(result.applied ? `  claude api usage totals: tables added ${result.tablesAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0034 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

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

@@ -26,12 +26,13 @@ export function isCompactBoundaryActivityEntry(item) {
 
 // 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.
+// compaction entries and the session-restart notes (a compaction window, a
+// billing switch) 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';
+  return kind === 'compact_boundary' || kind === 'compact_window_respawn' || kind === 'billing_switch_respawn';
 }
 export function capLiveActivityEntries(items, cap = LIVE_ACTIVITY_CAP) {
   const list = Array.isArray(items) ? items : [];

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

@@ -1,5 +1,5 @@
 // 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
+// sessions on this relay through the 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

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

@@ -1,5 +1,5 @@
 // Pure helpers for Settings → Relays → Agent sessions: whether agents may
-// start and use sessions on this relay, and the longest time one remote_relay
+// start and use sessions on this relay, and the longest time one relay_tool
 // 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.
 //

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

@@ -530,6 +530,90 @@ export async function updateCursorSettings({
   return settingsRequest('/api/settings/cursor', payload, 'Failed to update Cursor settings');
 }
 
+export async function loadDeepSeekSettings() {
+  return apiFetch('/api/settings/deepseek');
+}
+
+/**
+ * Saves what the caller names: a key (written, never read back), the switch,
+ * the default model, the enabled models, the base URL (null = DeepSeek's
+ * own), the attribution and the monthly budget (null = none); `remove`
+ * takes the key out.
+ */
+export async function updateDeepSeekSettings({
+  apiKey = '',
+  model = undefined,
+  enabled = undefined,
+  enabledModels = undefined,
+  baseUrl = undefined,
+  attribution = undefined,
+  monthlyBudget = undefined,
+  monthlyBudgetCurrency = undefined,
+  startingBalance = undefined,
+  startingBalanceEdited = undefined,
+  remove = false,
+} = {}) {
+  // Only the fields named here reach the relay: a field the DeepSeek tab
+  // shows needs its line below (api-client.deepseek-settings.test.mjs).
+  const payload = remove === true ? { remove: true } : {};
+  if (!payload.remove) {
+    const key = String(apiKey || '').trim();
+    if (key) payload.apiKey = key;
+    if (typeof model === 'string' && model.trim()) payload.model = model.trim();
+    if (typeof enabled === 'boolean') payload.enabled = enabled;
+    if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+    if (baseUrl === null || typeof baseUrl === 'string') payload.baseUrl = baseUrl === null ? null : String(baseUrl).trim();
+    if (typeof attribution === 'string' && attribution.trim()) payload.attribution = attribution.trim();
+    if (monthlyBudget === null || (typeof monthlyBudget === 'number' && Number.isFinite(monthlyBudget))) payload.monthlyBudget = monthlyBudget;
+    // 'USD' or 'CNY'; null is the balance's currency.
+    if (monthlyBudgetCurrency === null || typeof monthlyBudgetCurrency === 'string') {
+      payload.monthlyBudgetCurrency = String(monthlyBudgetCurrency ?? '').trim() || null;
+    }
+    if (startingBalance === null || (typeof startingBalance === 'number' && Number.isFinite(startingBalance))) payload.startingBalance = startingBalance;
+    if (typeof startingBalanceEdited === 'boolean') payload.startingBalanceEdited = startingBalanceEdited;
+  }
+  return settingsRequest('/api/settings/deepseek', payload, 'Failed to update DeepSeek settings');
+}
+
+export async function loadClaudeApiSettings() {
+  return apiFetch('/api/settings/claude-api');
+}
+
+/**
+ * Saves what the caller names on the Claude API tab: a key (written, never
+ * read back), the switch, the default model, the enabled models and the
+ * monthly cap in US dollars (null = no cap); `remove` takes the key out.
+ */
+export async function updateClaudeApiSettings({
+  apiKey = '',
+  model = undefined,
+  enabled = undefined,
+  enabledModels = undefined,
+  monthlyCapUsd = undefined,
+  remove = false,
+} = {}) {
+  // Only the fields named here reach the relay: a field the Claude API tab
+  // shows needs its line below (api-client.claude-api-settings.test.mjs).
+  const payload = remove === true ? { remove: true } : {};
+  if (!payload.remove) {
+    const key = String(apiKey || '').trim();
+    if (key) payload.apiKey = key;
+    if (typeof model === 'string' && model.trim()) payload.model = model.trim();
+    if (typeof enabled === 'boolean') payload.enabled = enabled;
+    if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+    if (monthlyCapUsd === null || (typeof monthlyCapUsd === 'number' && Number.isFinite(monthlyCapUsd))) payload.monthlyCapUsd = monthlyCapUsd;
+  }
+  return settingsRequest('/api/settings/claude-api', payload, 'Failed to update Claude API settings');
+}
+
+/**
+ * Imports DeepSeek's usage export: the texts of its amount and cost files.
+ * Answers `{ ok, summary }`; a refused export throws with the relay's reason.
+ */
+export async function importDeepSeekUsageExport({ amount, cost }) {
+  return settingsRequest('/api/deepseek-usage-import', { amount, cost }, 'Failed to import the DeepSeek usage export');
+}
+
 export async function loadWindowsAutostartSetting() {
   return apiFetchOrThrow('/api/settings/windows-autostart');
 }
@@ -1426,6 +1510,27 @@ export async function resumeUsageLimitPause(conversationId) {
   });
 }
 
+// Move a Claude chat between the subscription ("claude") and the saved API
+// key ("claude-api"), from its next turn. `by: "usage-limit"` is the
+// usage-limit note's button. `{ ok: true, ... }`, else `{ ok: false, error,
+// code }` with the relay's reason (the key, the model, the cap).
+export async function switchConversationBilling(conversationId, { to, by = 'user' } = {}) {
+  let refusal = null;
+  const result = await apiFetch(`/api/conversation/${encodeURIComponent(String(conversationId || ''))}/billing`, {
+    method: 'POST',
+    body: JSON.stringify({ to, by }),
+    onErrorResponse: async (response) => {
+      const payload = await response.json().catch(() => null);
+      refusal = {
+        ok: false,
+        error: readableServerError(payload?.error) || `The relay answered ${response.status}.`,
+        code: payload?.code || null,
+      };
+    },
+  });
+  return result || refusal || { ok: false, error: 'The relay could not be reached.', code: null };
+}
+
 export async function cancelUsageLimitPause(conversationId) {
   return apiFetch('/api/usage-limit/cancel', {
     method: 'POST',