Class SessionUsageService

src/node/services/sessionUsageService.ts:89–526

}

export class SessionUsageService {
  private readonly SESSION_USAGE_FILE = "session-usage.json";
  private readonly fileLocks = workspaceFileLocks;
  private readonly config: Config;
  private readonly historyService: HistoryService;

  constructor(config: Config, historyService: HistoryService) {
    this.config = config;
    this.historyService = historyService;
  }
  /**
   * Collect all messages from iterateFullHistory into an array.
   * Usage rebuild needs every epoch for accurate totals.
   */
  private async collectFullHistory(workspaceId: string): Promise<MuxMessage[]> {
    const messages: MuxMessage[] = [];
    const result = await this.historyService.iterateFullHistory(workspaceId, "forward", (chunk) => {
      messages.push(...chunk);
    });
    if (!result.success) {
      log.warn(`Failed to iterate history for ${workspaceId}: ${result.error}`);
      return [];
    }
    return messages;
  }

  private getFilePath(workspaceId: string): string {
    return path.join(this.config.getSessionDir(workspaceId), this.SESSION_USAGE_FILE);
  }

  private createEmptyUsageFile(): SessionUsageFile {
    return { byModel: {}, version: 1 };
  }

  private async readFile(workspaceId: string): Promise<SessionUsageFile> {
    try {
      const data = await fs.readFile(this.getFilePath(workspaceId), "utf-8");
      return JSON.parse(data) as SessionUsageFile;
    } catch (error) {
      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
        return this.createEmptyUsageFile();
      }
      throw error;
    }
  }

  private async writeFile(workspaceId: string, data: SessionUsageFile): Promise<void> {
    const filePath = this.getFilePath(workspaceId);
    await fs.mkdir(path.dirname(filePath), { recursive: true });
    await writeFileAtomic(filePath, JSON.stringify(data, null, 2));
  }

  /**
   * Record usage from a completed stream. Accumulates with existing usage
   * AND updates lastRequest in a single atomic write.
   * Model should already be normalized via normalizeToCanonical().
   */
  async recordUsage(workspaceId: string, model: string, usage: ChatUsageDisplay): Promise<void> {