@token-dashboard/codex-usage-uploader 0.1.6 → 0.1.7

package/src/collector.js

@@ -1,676 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { createInterface } from 'node:readline';
-import { loadCodexAuthIdentity, identityIsBound, promptValue } from './auth.js';
-import { RolloutParser } from './parser.js';
-import { StateDb } from './state-db.js';
-import { nowTs, sleep, stableStringify, readPersistentCollectorId, writePersistentCollectorId } from './utils.js';
-import {
-  ARCHIVED_SESSIONS_SOURCE_ROOT,
-  MAX_BATCH_BYTES,
-  MAX_EVENTS_PER_BATCH,
-  PERSISTENT_COLLECTOR_ID_PATH,
-  REGISTER_REFRESH_SECONDS,
-  SCAN_CHUNK_MAX_BYTES,
-  SCAN_CHUNK_MAX_EVENTS,
-  SESSIONS_SOURCE_ROOT,
-} from './constants.js';
-
-export class CodexUsageUploader {
-  constructor({
-    sessionsDir,
-    stateDbPath,
-    backendUrl,
-    intervalSeconds,
-    codexAuthPath,
-    persistentCollectorIdPath = PERSISTENT_COLLECTOR_ID_PATH,
-    scanChunkMaxEvents = SCAN_CHUNK_MAX_EVENTS,
-    scanChunkMaxBytes = SCAN_CHUNK_MAX_BYTES,
-  }) {
-    this.sessionsDir = sessionsDir;
-    this.stateDb = new StateDb(stateDbPath);
-    this.backendUrl = backendUrl?.replace(/\/+$/, '') || null;
-    this.intervalSeconds = intervalSeconds;
-    this.codexAuthPath = codexAuthPath;
-    this.persistentCollectorIdPath = persistentCollectorIdPath;
-    this.scanChunkMaxEvents = scanChunkMaxEvents;
-    this.scanChunkMaxBytes = scanChunkMaxBytes;
-    this.identity = this.ensureIdentity();
-  }
-
-  close() {
-    this.stateDb.close();
-  }
-
-  ensureIdentity() {
-    const identity = this.stateDb.getIdentity();
-    if (!identity.collectorId) {
-      const persisted = readPersistentCollectorId(this.persistentCollectorIdPath);
-      identity.collectorId = persisted ?? `${Date.now().toString(16)}${Math.random()
-        .toString(16)
-        .slice(2, 14)}`;
-    }
-    writePersistentCollectorId(this.persistentCollectorIdPath, identity.collectorId);
-    if (!identity.deviceId) {
-      identity.deviceId = `${os.hostname()}-${Math.random()
-        .toString(16)
-        .slice(2, 14)}`;
-    }
-    if (!identity.hostname) {
-      identity.hostname = os.hostname();
-    }
-    const detected = loadCodexAuthIdentity(this.codexAuthPath);
-    for (const key of ['employeeEmail', 'employeeName']) {
-      if (!identity[key] && detected[key]) {
-        identity[key] = detected[key];
-      }
-    }
-    this.stateDb.setIdentity(identity);
-    return this.stateDb.getIdentity();
-  }
-
-  resolveIdentityValues({
-    employeeId = undefined,
-    employeeEmail = undefined,
-    employeeName = undefined,
-    deviceId = undefined,
-    hostname = undefined,
-  } = {}) {
-    const current = this.stateDb.getIdentity();
-    const detected = loadCodexAuthIdentity(this.codexAuthPath);
-    return {
-      employeeId:
-        employeeId !== undefined ? employeeId : current.employeeId ?? null,
-      employeeEmail:
-        employeeEmail !== undefined
-          ? employeeEmail
-          : current.employeeEmail ?? detected.employeeEmail ?? null,
-      employeeName:
-        employeeName !== undefined
-          ? employeeName
-          : current.employeeName ?? detected.employeeName ?? null,
-      deviceId: deviceId !== undefined ? deviceId : current.deviceId ?? null,
-      hostname: hostname !== undefined ? hostname : current.hostname ?? null,
-    };
-  }
-
-  configureIdentity({
-    employeeId = null,
-    employeeEmail = null,
-    employeeName = null,
-    deviceId = undefined,
-    hostname = undefined,
-  } = {}) {
-    const updates = { employeeId, employeeEmail, employeeName };
-    if (!identityIsBound(updates)) {
-      throw new Error(
-        'At least one of employeeId, employeeEmail, or employeeName must be provided.',
-      );
-    }
-    if (deviceId !== undefined) updates.deviceId = deviceId;
-    if (hostname !== undefined) updates.hostname = hostname;
-    this.stateDb.setIdentity(updates);
-    this.identity = this.ensureIdentity();
-    return this.identity;
-  }
-
-  configureIdentityWithDefaults(overrides = {}) {
-    const resolved = this.resolveIdentityValues(overrides);
-    return this.configureIdentity(resolved);
-  }
-
-  async configureIdentityInteractive(overrides = {}) {
-    const resolved = this.resolveIdentityValues(overrides);
-    const detected = loadCodexAuthIdentity(this.codexAuthPath);
-    if (detected.employeeEmail || detected.employeeName) {
-      console.log(
-        'Detected identity defaults from ~/.codex/auth.json. Press Enter to accept.',
-      );
-    }
-    if (overrides.employeeEmail === undefined) {
-      resolved.employeeEmail = await promptValue(
-        'Employee email',
-        resolved.employeeEmail,
-      );
-    }
-    if (identityIsBound(resolved)) {
-      return this.configureIdentity(resolved);
-    }
-    if (overrides.employeeName === undefined) {
-      resolved.employeeName = await promptValue(
-        'Employee name',
-        resolved.employeeName,
-      );
-    }
-    if (identityIsBound(resolved)) {
-      return this.configureIdentity(resolved);
-    }
-    if (overrides.employeeId === undefined) {
-      resolved.employeeId = await promptValue(
-        'Employee ID',
-        resolved.employeeId,
-      );
-    }
-    return this.configureIdentity(resolved);
-  }
-
-  resetBackfillState() {
-    this.stateDb.resetBackfillState();
-  }
-
-  getQueueStats() {
-    return this.stateDb.getQueueStats();
-  }
-
-  getArchivedSessionsDir() {
-    return path.join(path.dirname(this.sessionsDir), ARCHIVED_SESSIONS_SOURCE_ROOT);
-  }
-
-  getScanRoots({ includeArchived = false } = {}) {
-    const roots = [
-      {
-        sourceRoot: SESSIONS_SOURCE_ROOT,
-        dir: this.sessionsDir,
-      },
-    ];
-    if (includeArchived) {
-      roots.push({
-        sourceRoot: ARCHIVED_SESSIONS_SOURCE_ROOT,
-        dir: this.getArchivedSessionsDir(),
-      });
-    }
-    return roots;
-  }
-
-  iterRolloutFiles(rootDir) {
-    if (!fs.existsSync(rootDir)) return [];
-    const files = [];
-    const walk = (dir) => {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          walk(fullPath);
-        } else if (entry.isFile() && /^rollout-.*\.jsonl$/.test(entry.name)) {
-          files.push(fullPath);
-        }
-      }
-    };
-    walk(rootDir);
-    files.sort();
-    return files;
-  }
-
-  buildSnapshot({ includeArchived = false } = {}) {
-    const entries = [];
-    for (const root of this.getScanRoots({ includeArchived })) {
-      for (const filePath of this.iterRolloutFiles(root.dir)) {
-        const relpath = path.relative(root.dir, filePath).split(path.sep).join('/');
-        const stat = fs.statSync(filePath, { bigint: true });
-        const existing = this.stateDb.getFileState(root.sourceRoot, relpath);
-        const fallbackState =
-          !existing && root.sourceRoot === ARCHIVED_SESSIONS_SOURCE_ROOT
-            ? this.stateDb.getFileState(SESSIONS_SOURCE_ROOT, relpath)
-            : null;
-        if (
-          existing &&
-          existing.file_size === stat.size &&
-          existing.file_mtime_ns === stat.mtimeNs
-        ) {
-          continue;
-        }
-        entries.push({
-          filePath,
-          relpath,
-          sourceRoot: root.sourceRoot,
-          progressPath: `${root.sourceRoot}/${relpath}`,
-          snapshotSize: stat.size,
-          snapshotMtimeNs: stat.mtimeNs,
-          fallbackState,
-        });
-      }
-    }
-    return entries;
-  }
-
-  buildBackfillSnapshot() {
-    return this.buildSnapshot({ includeArchived: true });
-  }
-
-  emptyPayload() {
-    return { sessions: [], turns: [], events: [] };
-  }
-
-  payloadHasData(payload) {
-    return Boolean(
-      payload.sessions.length || payload.turns.length || payload.events.length,
-    );
-  }
-
-  payloadBytes(payload) {
-    return Buffer.byteLength(stableStringify(payload), 'utf8');
-  }
-
-  mergePayload(basePayload, incoming) {
-    const sessions = new Map(
-      (basePayload.sessions ?? []).map((item) => [item.sessionId, item]),
-    );
-    const turns = new Map(
-      (basePayload.turns ?? []).map((item) => [item.turnId, item]),
-    );
-    const events = new Map(
-      (basePayload.events ?? []).map((item) => [item.eventUid, item]),
-    );
-    for (const item of incoming.sessions ?? []) sessions.set(item.sessionId, item);
-    for (const item of incoming.turns ?? []) turns.set(item.turnId, item);
-    for (const item of incoming.events ?? []) events.set(item.eventUid, item);
-    return {
-      sessions: [...sessions.values()],
-      turns: [...turns.values()],
-      events: [...events.values()],
-    };
-  }
-
-  shouldFlushChunk(payload) {
-    if (!this.payloadHasData(payload)) return false;
-    return (
-      payload.events.length >= this.scanChunkMaxEvents ||
-      this.payloadBytes(payload) >= this.scanChunkMaxBytes
-    );
-  }
-
-  wouldExceedUploadThreshold(payload) {
-    if (!this.payloadHasData(payload)) return false;
-    return (
-      payload.events.length > MAX_EVENTS_PER_BATCH ||
-      this.payloadBytes(payload) > MAX_BATCH_BYTES
-    );
-  }
-
-  appendPayloadToBuffer(incoming) {
-    if (!this.payloadHasData(incoming)) {
-      return 0;
-    }
-    const existing = this.stateDb.getBufferingBatch();
-    let queuedBatches = 0;
-    let payloadToSave = incoming;
-
-    if (existing) {
-      const basePayload = JSON.parse(existing.payload_json);
-      const merged = this.mergePayload(basePayload, incoming);
-      if (this.wouldExceedUploadThreshold(merged)) {
-        queuedBatches += this.stateDb.sealStaleBatches(true);
-      } else {
-        payloadToSave = merged;
-      }
-    }
-
-    this.stateDb.saveBufferingPayload(payloadToSave);
-    return queuedBatches + (this.stateDb.sealBufferIfThresholdHit() ? 1 : 0);
-  }
-
-  async scanSnapshotEntries(entries, { onFileProcessed } = {}) {
-    const result = {
-      filesScanned: 0,
-      sessions: 0,
-      turns: 0,
-      events: 0,
-      batchesQueued: 0,
-    };
-
-    for (const entry of entries) {
-      const {
-        filePath,
-        relpath,
-        sourceRoot,
-        snapshotSize,
-        snapshotMtimeNs,
-        fallbackState,
-      } = entry;
-      const existing = this.stateDb.getFileState(sourceRoot, relpath);
-      const baselineState = existing ?? fallbackState ?? null;
-      result.filesScanned += 1;
-
-      if (
-        !existing &&
-        fallbackState &&
-        fallbackState.file_size === snapshotSize &&
-        fallbackState.file_mtime_ns === snapshotMtimeNs
-      ) {
-        this.stateDb.upsertFileState(
-          sourceRoot,
-          relpath,
-          snapshotSize,
-          snapshotMtimeNs,
-          Number(fallbackState.last_line_no),
-          JSON.parse(fallbackState.state_json || '{}'),
-        );
-        onFileProcessed?.({
-          entry,
-          filesProcessed: result.filesScanned,
-          totals: {
-            filesScanned: result.filesScanned,
-            sessions: result.sessions,
-            turns: result.turns,
-            events: result.events,
-            batchesQueued: result.batchesQueued,
-          },
-        });
-        continue;
-      }
-
-      let parserState = {};
-      let startLineNo = 0;
-      if (baselineState && snapshotSize > baselineState.file_size) {
-        startLineNo = Number(baselineState.last_line_no);
-        parserState = JSON.parse(baselineState.state_json || '{}');
-      }
-
-      const parser = new RolloutParser(this.identity, relpath, parserState);
-      let fileChunk = this.emptyPayload();
-      let lastLineNo = 0;
-      let lineNo = 0;
-
-      if (Number(snapshotSize) > 0) {
-        const input = fs.createReadStream(filePath, {
-          encoding: 'utf8',
-          start: 0,
-          end: Number(snapshotSize) - 1,
-        });
-        const rl = createInterface({ input, crlfDelay: Infinity });
-
-        try {
-          for await (const line of rl) {
-            lineNo += 1;
-            if (!line) continue;
-            lastLineNo = lineNo;
-            if (lineNo <= startLineNo) continue;
-            const parsed = parser.processLine(lineNo, line);
-            result.sessions += parsed.sessions.length;
-            result.turns += parsed.turns.length;
-            result.events += parsed.events.length;
-            fileChunk = this.mergePayload(fileChunk, parsed);
-            if (this.shouldFlushChunk(fileChunk)) {
-              result.batchesQueued += this.appendPayloadToBuffer(fileChunk);
-              fileChunk = this.emptyPayload();
-            }
-          }
-        } finally {
-          rl.close();
-        }
-      }
-
-      if (this.payloadHasData(fileChunk)) {
-        result.batchesQueued += this.appendPayloadToBuffer(fileChunk);
-      }
-
-      this.stateDb.upsertFileState(
-        sourceRoot,
-        relpath,
-        snapshotSize,
-        snapshotMtimeNs,
-        lastLineNo,
-        parser.exportState(),
-      );
-
-      onFileProcessed?.({
-        entry,
-        filesProcessed: result.filesScanned,
-        totals: {
-          filesScanned: result.filesScanned,
-          sessions: result.sessions,
-          turns: result.turns,
-          events: result.events,
-          batchesQueued: result.batchesQueued,
-        },
-      });
-    }
-
-    return result;
-  }
-
-  async scanRollouts() {
-    return this.scanSnapshotEntries(this.buildSnapshot());
-  }
-
-  collectorRequestBody() {
-    return {
-      collectorId: this.identity.collectorId,
-      deviceId: this.identity.deviceId,
-      hostname: this.identity.hostname ?? null,
-      employeeId: this.identity.employeeId ?? null,
-      employeeEmail: this.identity.employeeEmail ?? null,
-      employeeName: this.identity.employeeName ?? null,
-    };
-  }
-
-  sanitizeUploadPayload(payload) {
-    return {
-      sessions: Array.isArray(payload.sessions) ? payload.sessions : [],
-      turns: Array.isArray(payload.turns) ? payload.turns : [],
-      events: Array.isArray(payload.events)
-        ? payload.events.map((event) => ({
-            ...event,
-            credits:
-              typeof event?.credits === 'number' && Number.isFinite(event.credits)
-                ? event.credits
-                : event?.credits &&
-                    typeof event.credits === 'object' &&
-                    typeof event.credits.balance === 'number' &&
-                    Number.isFinite(event.credits.balance)
-                  ? event.credits.balance
-                  : null,
-          }))
-        : [],
-    };
-  }
-
-  async postJson(apiPath, payload) {
-    if (!this.backendUrl) throw new Error('backendUrl is not configured');
-    const response = await fetch(`${this.backendUrl}${apiPath}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      const detail = text ? `: ${text.slice(0, 500)}` : '';
-      throw new Error(`HTTP ${response.status} ${response.statusText}${detail}`);
-    }
-    const text = await response.text();
-    return text ? JSON.parse(text) : {};
-  }
-
-  async ensureRemoteRegistration() {
-    if (!this.backendUrl) return;
-    const checkpoint = this.stateDb.getCheckpoint('last_register_at');
-    if (checkpoint && nowTs() - Number(checkpoint) < REGISTER_REFRESH_SECONDS) {
-      return;
-    }
-    await this.postJson(
-      '/codex-usage/collectors/register',
-      this.collectorRequestBody(),
-    );
-    this.stateDb.setCheckpoint('last_register_at', String(nowTs()));
-  }
-
-  async flushPendingBatches({ failFast = false, concurrency = 5, onBatchUploaded } = {}) {
-    if (!this.backendUrl) {
-      return { uploadedBatches: 0, failedBatches: 0, lastError: null };
-    }
-    try {
-      await this.ensureRemoteRegistration();
-    } catch (error) {
-      if (failFast) {
-        throw new Error(
-          `Collector registration failed: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-      return { uploadedBatches: 0, failedBatches: 1, lastError: error };
-    }
-
-    let uploadedBatches = 0;
-    let failedBatches = 0;
-    let lastError = null;
-    const collectorBody = this.collectorRequestBody();
-
-    const rows = this.stateDb.iterPendingBatches();
-
-    const uploadOne = async (row) => {
-      const payload = this.sanitizeUploadPayload(JSON.parse(row.payload_json));
-      const requestBody = {
-        idempotencyKey: row.batch_key,
-        collector: collectorBody,
-        payloadSizeBytes: Number(row.payload_bytes),
-        sessions: payload.sessions ?? [],
-        turns: payload.turns ?? [],
-        events: payload.events ?? [],
-      };
-      await this.postJson('/codex-usage/upload', requestBody);
-    };
-
-    const pending = new Set();
-    let rowIndex = 0;
-
-    const enqueue = () => {
-      while (pending.size < concurrency && rowIndex < rows.length) {
-        const row = rows[rowIndex++];
-        const task = uploadOne(row)
-          .then(() => {
-            this.stateDb.markBatchUploaded(row.id);
-            uploadedBatches += 1;
-            onBatchUploaded?.({ row, uploadedBatches });
-          })
-          .catch((error) => {
-            this.stateDb.markBatchFailed(
-              row.id,
-              Number(row.attempt_count) + 1,
-              error instanceof Error ? error.message : String(error),
-            );
-            failedBatches += 1;
-            lastError = error;
-            if (failFast) {
-              throw error;
-            }
-          })
-          .finally(() => {
-            pending.delete(task);
-          });
-        pending.add(task);
-      }
-    };
-
-    enqueue();
-    while (pending.size > 0) {
-      try {
-        await Promise.race(pending);
-      } catch {
-        if (failFast) break;
-      }
-      enqueue();
-    }
-
-    if (failFast && lastError) {
-      throw new Error(
-        `Upload batch failed: ${
-          lastError instanceof Error ? lastError.message : String(lastError)
-        }`,
-      );
-    }
-
-    return { uploadedBatches, failedBatches, lastError };
-  }
-
-  async runCycle({ forceSeal = false } = {}) {
-    const result = await this.scanRollouts();
-    result.batchesQueued += this.stateDb.sealStaleBatches(forceSeal);
-    const flushResult = await this.flushPendingBatches();
-    result.uploadedBatches = flushResult.uploadedBatches;
-    result.failedBatches = flushResult.failedBatches;
-    const queueStats = this.getQueueStats();
-    return {
-      ...result,
-      ...queueStats,
-      remainingQueuedBatches:
-        queueStats.bufferingBatchCount +
-        queueStats.pendingBatchCount +
-        queueStats.retryingBatchCount,
-      remainingQueuedEvents: queueStats.queuedEvents,
-    };
-  }
-
-  async runForegroundCatchUp({ snapshot, onProgress } = {}) {
-    const startedAt = Date.now();
-    const backfillSnapshot = snapshot ?? this.buildBackfillSnapshot();
-    const totalFiles = backfillSnapshot.length;
-    onProgress?.({
-      phase: 'start',
-      totalFiles,
-      filesProcessed: 0,
-      eventsParsed: 0,
-      batchesQueued: 0,
-    });
-
-    let scanResult;
-    try {
-      scanResult = await this.scanSnapshotEntries(backfillSnapshot, {
-        onFileProcessed: ({ entry, filesProcessed, totals }) => {
-          onProgress?.({
-            phase: 'file',
-            file: entry.progressPath ?? entry.relpath,
-            totalFiles,
-            filesProcessed,
-            eventsParsed: totals.events,
-            batchesQueued: totals.batchesQueued,
-          });
-        },
-      });
-    } catch (error) {
-      onProgress?.({
-        phase: 'error',
-        stage: 'scan',
-        message: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-
-    scanResult.batchesQueued += this.stateDb.sealStaleBatches(true);
-
-    await this.ensureRemoteRegistration();
-
-    const queueStats = this.getQueueStats();
-    const result = {
-      totalFiles,
-      filesProcessed: totalFiles,
-      eventsParsed: scanResult.events,
-      sessionsParsed: scanResult.sessions,
-      turnsParsed: scanResult.turns,
-      batchesQueued: scanResult.batchesQueued,
-      pendingBatches:
-        queueStats.pendingBatchCount + queueStats.retryingBatchCount,
-      pendingEvents: queueStats.queuedEvents,
-      durationMs: Date.now() - startedAt,
-    };
-
-    onProgress?.({
-      phase: 'done',
-      ...result,
-    });
-
-    return result;
-  }
-
-  async watch() {
-    let firstCycle = true;
-    while (true) {
-      const result = await this.runCycle({ forceSeal: firstCycle });
-      console.log(
-        `[uploader] scanned_files=${result.filesScanned} sessions=${result.sessions} turns=${result.turns} events=${result.events} queued_batches=${result.batchesQueued} uploaded_batches=${result.uploadedBatches} remaining_batches=${result.remainingQueuedBatches}`,
-      );
-      firstCycle = false;
-      await sleep(this.intervalSeconds * 1000);
-    }
-  }
-}

package/src/constants.js

@@ -1,44 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-
-export const PRODUCT_NAME = 'Codex 用量上报';
-export const CLI_NAME = 'codex-usage-uploader';
-export const SESSIONS_SOURCE_ROOT = 'sessions';
-export const ARCHIVED_SESSIONS_SOURCE_ROOT = 'archived_sessions';
-export const DEFAULT_CODEX_AUTH_PATH = path.join(os.homedir(), '.codex', 'auth.json');
-export const DEFAULT_SESSIONS_DIR = path.join(os.homedir(), '.codex', 'sessions');
-export const DEFAULT_INSTALL_ROOT = path.join(os.homedir(), '.codex-usage-uploader');
-export const DEFAULT_CONFIG_FILE = path.join(DEFAULT_INSTALL_ROOT, 'config.json');
-export const DEFAULT_STATE_DB = path.join(DEFAULT_INSTALL_ROOT, 'state.sqlite');
-export const DEFAULT_LOG_DIR = path.join(DEFAULT_INSTALL_ROOT, 'logs');
-export const DEFAULT_STDOUT_LOG_PATH = path.join(DEFAULT_LOG_DIR, 'stdout.log');
-export const DEFAULT_STDERR_LOG_PATH = path.join(DEFAULT_LOG_DIR, 'stderr.log');
-export const DEFAULT_APP_ROOT = path.join(DEFAULT_INSTALL_ROOT, 'app');
-export const DEFAULT_CURRENT_APP_DIR = path.join(DEFAULT_APP_ROOT, 'current');
-export const DEFAULT_LOCAL_BIN_DIR = path.join(DEFAULT_INSTALL_ROOT, 'bin');
-export const DEFAULT_LOCAL_BIN_PATH = path.join(DEFAULT_LOCAL_BIN_DIR, CLI_NAME);
-export const DEFAULT_HOME_BIN_LINK = path.join(os.homedir(), 'bin', CLI_NAME);
-export const DEFAULT_LAUNCHD_LABEL = 'com.token-dashboard.codex-usage-uploader';
-export const DEFAULT_PLIST_PATH = path.join(
-  DEFAULT_INSTALL_ROOT,
-  'launchd',
-  `${DEFAULT_LAUNCHD_LABEL}.plist`,
-);
-export const DEFAULT_LAUNCH_AGENT_PATH = path.join(
-  os.homedir(),
-  'Library',
-  'LaunchAgents',
-  `${DEFAULT_LAUNCHD_LABEL}.plist`,
-);
-export const PERSISTENT_COLLECTOR_ID_PATH = path.join(
-  os.homedir(),
-  '.codex-usage-uploader-collector-id',
-);
-export const DEFAULT_BACKEND_URL = 'http://101.126.66.51:8086';
-export const SCAN_CHUNK_MAX_EVENTS = 50;
-export const SCAN_CHUNK_MAX_BYTES = 256 * 1024;
-export const MAX_EVENTS_PER_BATCH = 200;
-export const MAX_BATCH_BYTES = 1_000_000;
-export const MAX_BUFFER_AGE_SECONDS = 60;
-export const REGISTER_REFRESH_SECONDS = 600;
-export const STATUS_ONLINE_THRESHOLD_SECONDS = 600;