@oar-sh/oar 0.9.16 → 0.9.17

package/server/migrations/0028-deepseek-usage-checkpoint-request-runs.mjs

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * Migration: the DeepSeek usage checkpoint keeps the run id of its web
+ * search and fetch counts apart from the run id of its token totals
+ * (services/plan-usage-service.mjs, the DeepSeek card in Check Usage).
+ * Builds on 0027.
+ *
+ * `deepseek_usage_checkpoints` gains one column:
+ * - `request_run_id`: the worker's id of the Claude Code process the
+ *   `search_requests` and `fetch_requests` counts came from; '' before any
+ *   report with a run id carried counts for the model. With 0027 one
+ *   `run_id` served both the totals and the counts, so a report that
+ *   carried only counts for a model (a sub-agent's model that searched
+ *   without a token entry of its own) moved the run id of that model's token
+ *   totals too: a later token report of the earlier process was then read
+ *   as a new process and booked in full instead of as a stale one. Now a
+ *   token entry moves `run_id` and a request entry moves `request_run_id`,
+ *   and neither disturbs the other.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0028-deepseek-usage-checkpoint-request-runs.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { DEEPSEEK_USAGE_CHECKPOINTS_TABLE } from './0024-deepseek-usage-totals.mjs';
+import { migrateDeepSeekUsageCheckpointRuns } from './0027-deepseek-usage-checkpoint-runs.mjs';
+
+// Added to deepseek_usage_checkpoints, with their DDL.
+export const DEEPSEEK_USAGE_CHECKPOINT_REQUEST_RUN_COLUMNS = Object.freeze([
+  ['request_run_id', "TEXT NOT NULL DEFAULT ''"],
+]);
+
+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) => column.name));
+}
+
+/** What keeps the service from using the column: '' when nothing does. */
+export function deepseekUsageCheckpointRequestRunsProblem(db) {
+  if (!tableExists(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE)) return `no ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} table`;
+  const present = columnNames(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE);
+  const missing = DEEPSEEK_USAGE_CHECKPOINT_REQUEST_RUN_COLUMNS.map(([name]) => name).filter((name) => !present.has(name));
+  if (missing.length) return `${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} lacks ${missing.join(', ')}`;
+  return '';
+}
+
+export function migrateDeepSeekUsageCheckpointRequestRuns(db) {
+  // The column goes next to 0027's: a database that skipped 0027 gets them first.
+  migrateDeepSeekUsageCheckpointRuns(db);
+  let columnsAdded = 0;
+  const present = columnNames(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE);
+  for (const [name, ddl] of DEEPSEEK_USAGE_CHECKPOINT_REQUEST_RUN_COLUMNS) {
+    if (present.has(name)) continue;
+    db.exec(`ALTER TABLE ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} ADD COLUMN ${name} ${ddl}`);
+    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 migrateDeepSeekUsageCheckpointRequestRuns(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 0028 on ${dbPath}`);
+    console.log(result.applied
+      ? `  deepseek usage checkpoint request runs: columns added ${result.columnsAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0028 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0029-deepseek-balance-rises.mjs

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * Migration: the DeepSeek balance reference notes when the balance last rose
+ * (services/plan-usage-service.mjs, the DeepSeek card's balance bar). Builds
+ * on 0025.
+ *
+ * `deepseek_balance_reference` gains these columns:
+ * - `rose_at`: when a read last found the balance above the read before it
+ *   (a top-up or a grant); NULL while no rise was seen. `reference_at` cannot
+ *   tell: it is also set by the first read of a currency. A starting balance
+ *   set on the DeepSeek tab counts until the balance rises after it was set
+ *   (plan-usage-deepseek.mjs).
+ * - `last_read_at`: when `last_total` was read; NULL for a row from before.
+ * - `rose_from_at`: when the balance before that rise was read; NULL when
+ *   unknown. A rise the relay first sees after the starting balance was set
+ *   may be a top-up from before it, unless the balance before the rise was
+ *   read after it too.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0029-deepseek-balance-rises.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { DEEPSEEK_BALANCE_REFERENCE_TABLE, migrateDeepSeekUsageRequestsDaily } from './0025-deepseek-usage-requests-daily.mjs';
+
+// Added to deepseek_balance_reference, with their DDL.
+export const DEEPSEEK_BALANCE_RISE_COLUMNS = Object.freeze([
+  ['rose_at', 'TEXT'],
+  ['last_read_at', 'TEXT'],
+  ['rose_from_at', '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) => column.name));
+}
+
+/** What keeps the service from using the column: '' when nothing does. */
+export function deepseekBalanceRisesProblem(db) {
+  if (!tableExists(db, DEEPSEEK_BALANCE_REFERENCE_TABLE)) return `no ${DEEPSEEK_BALANCE_REFERENCE_TABLE} table`;
+  const present = columnNames(db, DEEPSEEK_BALANCE_REFERENCE_TABLE);
+  const missing = DEEPSEEK_BALANCE_RISE_COLUMNS.map(([name]) => name).filter((name) => !present.has(name));
+  if (missing.length) return `${DEEPSEEK_BALANCE_REFERENCE_TABLE} lacks ${missing.join(', ')}`;
+  return '';
+}
+
+export function migrateDeepSeekBalanceRises(db) {
+  // The column goes on 0025's table: a database that skipped 0025 gets it first.
+  migrateDeepSeekUsageRequestsDaily(db);
+  let columnsAdded = 0;
+  const present = columnNames(db, DEEPSEEK_BALANCE_REFERENCE_TABLE);
+  for (const [name, ddl] of DEEPSEEK_BALANCE_RISE_COLUMNS) {
+    if (present.has(name)) continue;
+    db.exec(`ALTER TABLE ${DEEPSEEK_BALANCE_REFERENCE_TABLE} ADD COLUMN ${name} ${ddl}`);
+    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 migrateDeepSeekBalanceRises(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 0029 on ${dbPath}`);
+    console.log(result.applied
+      ? `  deepseek balance rises: columns added ${result.columnsAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0029 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0030-deepseek-usage-actuals.mjs

@@ -0,0 +1,123 @@
+'use strict';
+
+/**
+ * Migration: the figures of DeepSeek's own usage export, imported from the
+ * platform's two CSV files (services/deepseek-usage-import.mjs). The usage
+ * card in Check Usage shows them instead of the relay's estimate for the
+ * days and models they cover.
+ *
+ * Adds one table of its own, `deepseek_usage_actuals`, one row per export
+ * day, model and API key (the key is the day, so a re-export taken in
+ * another time zone replaces the day instead of adding a second row):
+ * - `day`: the local date of `period_start`, in the export's time zone;
+ * - `period_start`, `period_end`: the first start and last end of the day's
+ *   periods as the export gives them (ISO with the export's offset);
+ * - `model`, `key_fp` (the key masked as `sk-XXXXX…YYYY`), `key_name`;
+ * - `hit_tokens`, `miss_tokens`, `output_tokens`, `request_count`;
+ * - `cost`, `currency`: the period's cost, amount × price summed;
+ * - `imported_at`.
+ *
+ * The relay's own usage tables are not touched. Additive and idempotent.
+ * Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0030-deepseek-usage-actuals.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const DEEPSEEK_USAGE_ACTUALS_TABLE = 'deepseek_usage_actuals';
+
+export const DEEPSEEK_USAGE_ACTUALS_COLUMNS = Object.freeze([
+  'period_start',
+  'period_end',
+  'day',
+  'model',
+  'key_fp',
+  'key_name',
+  'hit_tokens',
+  'miss_tokens',
+  'output_tokens',
+  'request_count',
+  'cost',
+  'currency',
+  'imported_at',
+]);
+
+const CREATE_SQL = `
+  CREATE TABLE IF NOT EXISTS ${DEEPSEEK_USAGE_ACTUALS_TABLE} (
+    period_start TEXT NOT NULL,
+    period_end TEXT NOT NULL,
+    day TEXT NOT NULL,
+    model TEXT NOT NULL,
+    key_fp TEXT NOT NULL,
+    key_name TEXT NOT NULL DEFAULT '',
+    hit_tokens INTEGER NOT NULL DEFAULT 0,
+    miss_tokens INTEGER NOT NULL DEFAULT 0,
+    output_tokens INTEGER NOT NULL DEFAULT 0,
+    request_count INTEGER NOT NULL DEFAULT 0,
+    cost REAL NOT NULL DEFAULT 0,
+    currency TEXT NOT NULL DEFAULT '',
+    imported_at TEXT NOT NULL,
+    PRIMARY KEY (day, model, key_fp)
+  );
+  CREATE INDEX IF NOT EXISTS idx_${DEEPSEEK_USAGE_ACTUALS_TABLE}_key_day
+    ON ${DEEPSEEK_USAGE_ACTUALS_TABLE} (key_fp, day);
+`;
+
+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) => column.name));
+}
+
+/** What keeps the import from using the table: '' when nothing does. */
+export function deepseekUsageActualsProblem(db) {
+  if (!tableExists(db, DEEPSEEK_USAGE_ACTUALS_TABLE)) return `no ${DEEPSEEK_USAGE_ACTUALS_TABLE} table`;
+  const present = columnNames(db, DEEPSEEK_USAGE_ACTUALS_TABLE);
+  const missing = DEEPSEEK_USAGE_ACTUALS_COLUMNS.filter((name) => !present.has(name));
+  if (missing.length) return `${DEEPSEEK_USAGE_ACTUALS_TABLE} lacks ${missing.join(', ')}`;
+  return '';
+}
+
+export function migrateDeepSeekUsageActuals(db) {
+  const existed = tableExists(db, DEEPSEEK_USAGE_ACTUALS_TABLE);
+  db.exec(CREATE_SQL);
+  return { applied: !existed, tableCreated: !existed };
+}
+
+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 migrateDeepSeekUsageActuals(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 0030 on ${dbPath}`);
+    console.log(result.applied
+      ? '  deepseek usage actuals: table created'
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0030 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

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

@@ -530,6 +530,59 @@ 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');
+}
+
+/**
+ * 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');
 }