Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

10.9 KB
Raw Blame
/// What OpenCode has spent on this computer, read out of its own database.
///
/// The odd one of the three. OpenCode keeps no transcript to walk: it writes a
/// SQLite database at `$XDG_DATA_HOME/opencode/opencode.db` and maintains
/// per-session token and cost totals inside it. So there is no parsing here at
/// all — one query, one row per session — and no pricing table either, because
/// **OpenCode records the cost itself** and a figure the provider computed beats
/// one we inferred from a model name.
///
/// ⚠️ **A zero cost from OpenCode is a measurement, not a silence.** Every
/// session run against a Grid records `cost = 0.0`, because Grid inference is
/// free (grid ADR 0039 D-g). That must not read the same as Claude's unpriced
/// models, which is why `LedgerEntry.costUsd` is nullable and this scanner is
/// the only one that ever fills it in.
library;

import 'dart:convert';
import 'dart:io';
import 'dart:isolate';

import 'package:sqlite3/sqlite3.dart';

import 'ledger_scanner.dart';
import 'ledger_types.dart';

class _UnsupportedUsageFormat implements Exception {
  const _UnsupportedUsageFormat();
}

class OpenCodeLedgerScanner implements LedgerScanner {
  OpenCodeLedgerScanner({
    String? dataDirectory,
    Map<String, String>? environment,
  }) : _dataDirectory = dataDirectory ?? _resolveDataDirectory(environment);

  final String? _dataDirectory;

  @override
  LedgerProvider get provider => LedgerProvider.opencode;

  /// Where OpenCode keeps its data — XDG first, as OpenCode itself resolves it.
  static String? _resolveDataDirectory([Map<String, String>? environment]) {
    final env = environment ?? Platform.environment;
    final xdg = env['XDG_DATA_HOME']?.trim();
    if (xdg != null && xdg.isNotEmpty) return '$xdg/opencode';
    final home = homeDirectory(env);
    return home == null ? null : '$home/.local/share/opencode';
  }

  @override
  Future<LedgerScanResult> scan(Map<String, ScannedSource> previous) =>
      Isolate.run(() => _scanDirectory(_dataDirectory));

  static Future<LedgerScanResult> _scanDirectory(String? directory) async {
    if (directory == null) {
      return const LedgerScanResult.unavailable(
        'No home directory to read the OpenCode database from',
      );
    }
    final List<File> databases;
    try {
      databases = await _listDatabases(directory);
    } on FileSystemException catch (error) {
      return LedgerScanResult(
        status: LedgerStatus.failed,
        message:
            'Could not read OpenCode usage: ${error.osError?.message ?? error.message}',
      );
    }
    if (databases.isEmpty) {
      return const LedgerScanResult.unavailable(
        'No OpenCode database on this computer',
      );
    }

    final sources = <ScannedSource>[];
    final failures = <String>[];
    for (final file in databases) {
      try {
        final stat = await file.stat();
        if (stat.type != FileSystemEntityType.file) {
          failures.add('A database is no longer available.');
          continue;
        }
        // The main database can keep its size and mtime while commits change
        // only its WAL. WAL files can also be reused. Query SQLite's committed
        // snapshot on every requested scan instead of trusting file metadata.
        // This aggregate query runs off the UI isolate; the store still avoids
        // rescanning on every visit through its five-minute snapshot lifetime.
        final entries = _read(file.path);
        sources.add(
          ScannedSource(
            path: file.path,
            mtimeMs: stat.modified.millisecondsSinceEpoch,
            size: stat.size,
            entries: entries,
          ),
        );
      } on SqliteException catch (error) {
        failures.add(error.message);
      } on FileSystemException catch (error) {
        failures.add(error.osError?.message ?? error.message);
      } on _UnsupportedUsageFormat {
        failures.add('This OpenCode usage format is not supported yet.');
      }
    }
    return LedgerScanResult(
      sources: sources,
      status: failures.isEmpty
          ? LedgerStatus.ok
          : sources.isEmpty
          ? LedgerStatus.failed
          : LedgerStatus.partial,
      message: failures.isEmpty
          ? null
          : sources.isEmpty
          ? 'Could not read OpenCode usage: ${failures.first}'
          : 'Could not read ${failures.length} of ${databases.length} OpenCode databases. '
                'Figures are incomplete. ${failures.first}',
    );
  }

  /// `opencode.db` and its siblings, canonical one first.
  ///
  /// The canonical database is the live one and must claim a duplicated session
  /// ahead of a stale copy beside it; remaining ties go in path order so
  /// ownership is the same on every rescan.
  static Future<List<File>> _listDatabases(String directory) async {
    final dir = Directory(directory);
    final pattern = RegExp(r'^opencode(?:-[A-Za-z0-9_.-]+)?\.db$');
    final files = <File>[];
    try {
      await for (final entity in dir.list(followLinks: false)) {
        if (entity is! File) continue;
        if (pattern.hasMatch(entity.uri.pathSegments.last)) files.add(entity);
      }
    } on FileSystemException catch (error) {
      if (error.osError?.errorCode == 2) return const [];
      // Windows uses ERROR_PATH_NOT_FOUND for a missing directory and for
      // enumerating a file. Only the former means no local usage is present.
      if (Platform.isWindows &&
          error.osError?.errorCode == 3 &&
          await FileSystemEntity.type(directory, followLinks: false) ==
              FileSystemEntityType.notFound) {
        return const [];
      }
      rethrow;
    }
    files.sort((a, b) {
      final aRank = a.uri.pathSegments.last == 'opencode.db' ? 0 : 1;
      final bRank = b.uri.pathSegments.last == 'opencode.db' ? 0 : 1;
      if (aRank != bRank) return aRank - bRank;
      return a.path.compareTo(b.path);
    });
    return files;
  }

  static List<LedgerEntry> _read(String path) {
    // Read-only, so a scan can never write to a database the CLI owns — and
    // opening a live WAL database this way is fine, which is the case that
    // matters since OpenCode may be running while this scan happens.
    final db = sqlite3.open(path, mode: OpenMode.readOnly);
    try {
      if (!_hasTable(db, 'session')) throw const _UnsupportedUsageFormat();
      final columns = _columns(db, 'session');
      // Newer OpenCode keeps per-session totals. One aggregate row per session
      // is both cheaper and more accurate than re-adding every message blob.
      const required = [
        'id',
        'directory',
        'time_created',
        'cost',
        'tokens_input',
        'tokens_output',
        'tokens_reasoning',
        'tokens_cache_read',
      ];
      if (!required.every(columns.contains)) {
        throw const _UnsupportedUsageFormat();
      }
      final hasCacheWrite = columns.contains('tokens_cache_write');
      final hasModel = columns.contains('model');

      final rows = db.select(
        'SELECT id, directory, time_created, cost, '
        'tokens_input, tokens_output, tokens_reasoning, tokens_cache_read'
        '${hasCacheWrite ? ', tokens_cache_write' : ''}'
        '${hasModel ? ', model' : ''} '
        'FROM session '
        'WHERE tokens_input > 0 OR tokens_output > 0 OR tokens_reasoning > 0 OR tokens_cache_read > 0 '
        '${hasCacheWrite ? 'OR tokens_cache_write > 0 ' : ''}'
        'ORDER BY time_created, id',
      );

      return [
        for (final row in rows)
          ?_entry(row, hasCacheWrite: hasCacheWrite, hasModel: hasModel),
      ];
    } finally {
      db.dispose();
    }
  }

  static LedgerEntry? _entry(
    Row row, {
    required bool hasCacheWrite,
    required bool hasModel,
  }) {
    final id = row['id'];
    if (id is! String) return null;
    final created = row['time_created'];
    if (created is! int) return null;

    return LedgerEntry(
      provider: LedgerProvider.opencode,
      sessionId: id,
      // Epoch MILLISECONDS, unlike the seconds most SQLite schemas store — read
      // off a live database rather than assumed.
      timestamp: DateTime.fromMillisecondsSinceEpoch(created),
      totals: UsageTotals(
        // `tokens_input` is a peer of `tokens_cache_read` here, as it is for
        // Claude, so no subtraction — see `UsageTotals.freshInput`.
        freshInput: _int(row['tokens_input']),
        // Reasoning folded into output to match the shared bucket's meaning; it
        // is billed at the output rate, and reported separately as a subset.
        output: _int(row['tokens_output']) + _int(row['tokens_reasoning']),
        reasoning: _int(row['tokens_reasoning']),
        cacheRead: _int(row['tokens_cache_read']),
        // OpenCode reports one cache-write figure and no TTL split, so it lands
        // on the 5m bucket rather than being guessed at as long-lived.
        cacheWrite5m: hasCacheWrite ? _int(row['tokens_cache_write']) : 0,
      ),
      model: hasModel ? _modelName(row['model']) : null,
      directory: row['directory'] as String?,
      costUsd: (row['cost'] as num?)?.toDouble(),
      // The session id is already unique per database, and the canonical-first
      // ordering above means a stale sibling copy of the same session is dropped
      // rather than counted twice.
      dedupeKey: 'opencode:$id',
    );
  }

  /// The model id out of OpenCode's `model` column.
  ///
  /// ⚠️ **That column holds JSON, not a name** — `{"id":"...","providerID":"..."}`
  /// — which is a real difference from Orca, whose query treats it as a plain
  /// string. Read off a live database. The plain-string form is still accepted
  /// because older schemas wrote one.
  static String? _modelName(Object? value) {
    if (value is! String || value.isEmpty) return null;
    if (!value.startsWith('{')) return value;
    try {
      final decoded = jsonDecode(value);
      if (decoded is Map<String, Object?>) {
        final id = decoded['id'];
        if (id is String && id.isNotEmpty) {
          final provider = decoded['providerID'];
          // Qualified, because the same model id means different things (and
          // different prices) behind two providers — `autonomous-ai` is a Grid,
          // and free.
          return provider is String && provider.isNotEmpty
              ? '$provider/$id'
              : id;
        }
      }
    } on FormatException {
      // A column that is neither JSON nor a bare name tells us nothing; an
      // unnamed model is already an ordinary state here, since OpenCode carries
      // its own cost and never needs the name to price anything.
    }
    return null;
  }

  static bool _hasTable(Database db, String name) => db.select(
    "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?",
    [name],
  ).isNotEmpty;

  static Set<String> _columns(Database db, String table) => {
    for (final row in db.select('PRAGMA table_info($table)'))
      if (row['name'] case final String name) name,
  };

  static int _int(Object? value) =>
      value is num && value.isFinite && value > 0 ? value.toInt() : 0;
}