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

package/src/install.js

@@ -1,156 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { CLI_NAME } from './constants.js';
-import { saveRuntimeConfig } from './runtime-config.js';
-
-const SHELL_CONFIG_MARKER = '# Added by codex-usage-uploader';
-const SHELL_CONFIG_FILES = [
-  path.join(os.homedir(), '.zshrc'),
-  path.join(os.homedir(), '.bash_profile'),
-];
-
-export function getPackageVersion(startUrl = import.meta.url) {
-  const root = findPackageRoot(startUrl);
-  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-  return pkg.version ?? 'unknown';
-}
-
-export function findPackageRoot(startUrl = import.meta.url) {
-  let current = path.dirname(fileURLToPath(startUrl));
-  while (true) {
-    const candidate = path.join(current, 'package.json');
-    if (fs.existsSync(candidate)) {
-      return current;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      throw new Error('package.json not found from current runtime');
-    }
-    current = parent;
-  }
-}
-
-export function resolveSelfPackageSpec(packageRoot, explicitSpec) {
-  if (explicitSpec) return explicitSpec;
-  return `file:${packageRoot}`;
-}
-
-export function installCurrentPackage(runtime, { packageRoot, packageSpec, nodePath = process.execPath } = {}) {
-  const resolvedSpec = resolveSelfPackageSpec(packageRoot, packageSpec);
-  const appRoot = runtime.appRoot;
-  const stagingDir = path.join(appRoot, `.staging-${Date.now()}`);
-  fs.mkdirSync(stagingDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(stagingDir, 'package.json'),
-    `${JSON.stringify({ private: true, name: 'codex-usage-uploader-runtime' }, null, 2)}\n`,
-  );
-
-  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const result = spawnSync(
-    npmCommand,
-    ['install', '--no-save', '--omit=dev', '--no-package-lock', resolvedSpec],
-    {
-      cwd: stagingDir,
-      stdio: 'inherit',
-      env: { ...process.env, npm_config_fund: 'false', npm_config_audit: 'false' },
-    },
-  );
-  if (result.error) {
-    throw new Error(`failed to execute ${npmCommand}: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new Error(`npm install failed for ${resolvedSpec}`);
-  }
-
-  const sourcePkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
-  const installedPackageRoot = path.join(stagingDir, 'node_modules', ...String(sourcePkg.name).split('/'));
-  const installedPkg = JSON.parse(fs.readFileSync(path.join(installedPackageRoot, 'package.json'), 'utf8'));
-  const binField = installedPkg.bin;
-  const binRel = typeof binField === 'string'
-    ? binField
-    : binField?.[CLI_NAME] ?? Object.values(binField ?? {})[0];
-  if (!binRel) {
-    throw new Error('installed package does not expose the expected CLI binary');
-  }
-
-  const currentDir = runtime.currentAppDir;
-  fs.rmSync(currentDir, { recursive: true, force: true });
-  fs.mkdirSync(path.dirname(currentDir), { recursive: true });
-  fs.renameSync(stagingDir, currentDir);
-
-  runtime.nodePath = nodePath;
-  runtime.packageSpec = resolvedSpec;
-  runtime.entryFile = path.join(currentDir, 'node_modules', ...String(sourcePkg.name).split('/'), binRel);
-  writeLocalWrapper(runtime);
-  ensureHomeBinLink(runtime);
-  saveRuntimeConfig(runtime);
-  return runtime;
-}
-
-export function writeLocalWrapper(runtime) {
-  fs.mkdirSync(runtime.localBinDir, { recursive: true });
-  const script = `#!/bin/sh
-set -eu
-CONFIG_FILE="\${CODEX_USAGE_UPLOADER_CONFIG:-${runtime.configFile}}"
-exec "${runtime.nodePath}" "${runtime.entryFile}" --config-file "$CONFIG_FILE" "$@"
-`;
-  fs.writeFileSync(runtime.localBinPath, script, { mode: 0o755 });
-  fs.chmodSync(runtime.localBinPath, 0o755);
-}
-
-export function ensureHomeBinLink(runtime) {
-  fs.mkdirSync(path.dirname(runtime.homeBinLink), { recursive: true });
-  try {
-    if (fs.existsSync(runtime.homeBinLink) || fs.lstatSync(runtime.homeBinLink).isSymbolicLink()) {
-      fs.rmSync(runtime.homeBinLink, { force: true });
-    }
-  } catch {
-    // ignore
-  }
-  fs.symlinkSync(runtime.localBinPath, runtime.homeBinLink);
-}
-
-export function ensurePathInShellConfigs(binDir) {
-  const exportLine = `export PATH="${binDir}:$PATH"`;
-  for (const configFile of SHELL_CONFIG_FILES) {
-    try {
-      if (!fs.existsSync(configFile)) continue;
-      const content = fs.readFileSync(configFile, 'utf8');
-      if (content.includes(SHELL_CONFIG_MARKER)) continue;
-      const prefix = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
-      fs.appendFileSync(configFile, `${prefix}\n${SHELL_CONFIG_MARKER}\n${exportLine}\n`);
-    } catch {
-      // best-effort, ignore errors
-    }
-  }
-}
-
-export function removePathFromShellConfigs() {
-  for (const configFile of SHELL_CONFIG_FILES) {
-    try {
-      if (!fs.existsSync(configFile)) continue;
-      const content = fs.readFileSync(configFile, 'utf8');
-      if (!content.includes(SHELL_CONFIG_MARKER)) continue;
-      const lines = content.split('\n');
-      const filtered = [];
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i] === SHELL_CONFIG_MARKER) {
-          if (i + 1 < lines.length && lines[i + 1].startsWith('export PATH=')) {
-            i += 1;
-          }
-          if (filtered.length > 0 && filtered[filtered.length - 1] === '') {
-            filtered.pop();
-          }
-          continue;
-        }
-        filtered.push(lines[i]);
-      }
-      fs.writeFileSync(configFile, filtered.join('\n'));
-    } catch {
-      // best-effort, ignore errors
-    }
-  }
-}

package/src/launchd.js

@@ -1,170 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-export function buildLaunchdPlist(runtime) {
-  const args = [
-    runtime.nodePath,
-    runtime.entryFile,
-    '--config-file',
-    runtime.configFile,
-    'run',
-  ];
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-  <dict>
-    <key>Label</key>
-    <string>${escapeXml(runtime.launchdLabel)}</string>
-    <key>ProgramArguments</key>
-    <array>
-${args.map((item) => `      <string>${escapeXml(item)}</string>`).join('\n')}
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>ProcessType</key>
-    <string>Background</string>
-    <key>WorkingDirectory</key>
-    <string>${escapeXml(runtime.installRoot)}</string>
-    <key>StandardOutPath</key>
-    <string>${escapeXml(runtime.stdoutLogPath)}</string>
-    <key>StandardErrorPath</key>
-    <string>${escapeXml(runtime.stderrLogPath)}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-      <key>NODE_NO_WARNINGS</key>
-      <string>1</string>
-    </dict>
-  </dict>
-</plist>
-`;
-}
-
-function escapeXml(value) {
-  return String(value)
-    .replaceAll('&', '&amp;')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&apos;');
-}
-
-export function parseLaunchctlPrint(output) {
-  const state = output.match(/^\s*state = ([^\n]+)$/m)?.[1]?.trim() ?? null;
-  const pidRaw = output.match(/^\s*pid = (\d+)$/m)?.[1] ?? null;
-  const exitRaw = output.match(/^\s*last exit code = (-?\d+)$/m)?.[1] ?? null;
-  return {
-    loaded: true,
-    running: state === 'running' || pidRaw != null,
-    pid: pidRaw ? Number(pidRaw) : null,
-    state,
-    lastExitCode: exitRaw ? Number(exitRaw) : null,
-  };
-}
-
-export class LaunchdServiceManager {
-  constructor(runtime) {
-    this.runtime = runtime;
-  }
-
-  ensureMacos() {
-    if (process.platform !== 'darwin') {
-      throw new Error('launchd management is only supported on macOS.');
-    }
-  }
-
-  domainTarget() {
-    return `gui/${process.getuid()}`;
-  }
-
-  serviceTarget() {
-    return `${this.domainTarget()}/${this.runtime.launchdLabel}`;
-  }
-
-  run(args, { check = true } = {}) {
-    const result = spawnSync(args[0], args.slice(1), { encoding: 'utf8' });
-    if (check && result.status !== 0) {
-      throw new Error(result.stderr?.trim() || result.stdout?.trim() || `command failed: ${args.join(' ')}`);
-    }
-    return result;
-  }
-
-  ensurePlist() {
-    this.ensureMacos();
-    if (!this.runtime.entryFile || !fs.existsSync(this.runtime.entryFile)) {
-      throw new Error(`installed runtime entry not found: ${this.runtime.entryFile || '(empty)'}`);
-    }
-    const plist = buildLaunchdPlist(this.runtime);
-    fs.mkdirSync(path.dirname(this.runtime.plistPath), { recursive: true });
-    fs.mkdirSync(path.dirname(this.runtime.stdoutLogPath), { recursive: true });
-    fs.writeFileSync(this.runtime.plistPath, plist);
-    this.syncLaunchAgent(plist);
-  }
-
-  syncLaunchAgent(plist) {
-    const launchAgentPath = this.runtime.launchAgentPath;
-    if (!launchAgentPath) {
-      return;
-    }
-    if (this.runtime.autoStartOnLogin) {
-      fs.mkdirSync(path.dirname(launchAgentPath), { recursive: true });
-      fs.writeFileSync(launchAgentPath, plist);
-      return;
-    }
-    if (fs.existsSync(launchAgentPath)) {
-      fs.rmSync(launchAgentPath, { force: true });
-    }
-  }
-
-  start() {
-    this.ensurePlist();
-    this.stop();
-    this.run(['launchctl', 'bootstrap', this.domainTarget(), this.runtime.plistPath]);
-  }
-
-  stop() {
-    this.ensureMacos();
-    this.run(['launchctl', 'bootout', this.serviceTarget()], { check: false });
-  }
-
-  restart() {
-    this.start();
-  }
-
-  status() {
-    this.ensureMacos();
-    const result = this.run(['launchctl', 'print', this.serviceTarget()], { check: false });
-    if (result.status !== 0) {
-      return {
-        loaded: false,
-        running: false,
-        pid: null,
-        state: null,
-        lastExitCode: null,
-      };
-    }
-    return parseLaunchctlPrint(result.stdout);
-  }
-
-  uninstall() {
-    this.stop();
-    if (fs.existsSync(this.runtime.plistPath)) {
-      fs.unlinkSync(this.runtime.plistPath);
-    }
-    if (this.runtime.launchAgentPath && fs.existsSync(this.runtime.launchAgentPath)) {
-      fs.unlinkSync(this.runtime.launchAgentPath);
-    }
-    if (fs.existsSync(this.runtime.homeBinLink) && fs.lstatSync(this.runtime.homeBinLink).isSymbolicLink()) {
-      try {
-        const target = fs.realpathSync.native(this.runtime.homeBinLink);
-        if (target === this.runtime.localBinPath) {
-          fs.unlinkSync(this.runtime.homeBinLink);
-        }
-      } catch {
-        fs.unlinkSync(this.runtime.homeBinLink);
-      }
-    }
-  }
-}

package/src/local-usage.js

@@ -1,342 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createInterface } from 'node:readline';
-import {
-  ARCHIVED_SESSIONS_SOURCE_ROOT,
-  SESSIONS_SOURCE_ROOT,
-} from './constants.js';
-import { RolloutParser } from './parser.js';
-
-const LOCAL_USAGE_COLLECTOR = Object.freeze({ collectorId: 'local-usage' });
-const VALID_PERIODS = new Set(['today', '7d', '30d', 'all']);
-const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-
-export function getLocalTimeZone() {
-  return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-}
-
-export function resolveUsageQuery({
-  period,
-  from,
-  to,
-  now = Date.now(),
-  timeZone = getLocalTimeZone(),
-} = {}) {
-  if (period && (from || to)) {
-    throw new Error('--period cannot be combined with --from or --to');
-  }
-
-  if (period && !VALID_PERIODS.has(period)) {
-    throw new Error(`--period must be one of: today, 7d, 30d, all`);
-  }
-
-  const today = formatDateInTimeZone(now, timeZone);
-
-  if (period === 'today') {
-    return {
-      mode: 'today',
-      from: today,
-      to: today,
-      trendFrom: today,
-      trendTo: today,
-    };
-  }
-
-  if (period === '7d') {
-    return {
-      mode: '7d',
-      from: addDays(today, -6),
-      to: today,
-      trendFrom: addDays(today, -6),
-      trendTo: today,
-    };
-  }
-
-  if (period === '30d') {
-    return {
-      mode: '30d',
-      from: addDays(today, -29),
-      to: today,
-      trendFrom: addDays(today, -29),
-      trendTo: today,
-    };
-  }
-
-  if (period === 'all' || (!period && !from && !to)) {
-    return {
-      mode: 'all',
-      from: null,
-      to: null,
-      trendFrom: addDays(today, -29),
-      trendTo: today,
-    };
-  }
-
-  const normalizedFrom = from == null ? null : normalizeDateString(from, '--from');
-  const normalizedTo = to == null ? null : normalizeDateString(to, '--to');
-
-  if (normalizedFrom && normalizedTo && normalizedFrom > normalizedTo) {
-    throw new Error('--from cannot be later than --to');
-  }
-
-  return {
-    mode: 'custom',
-    from: normalizedFrom,
-    to: normalizedTo,
-    trendFrom: normalizedFrom,
-    trendTo: normalizedTo,
-  };
-}
-
-export async function collectLocalUsage({
-  sessionsDir,
-  period,
-  from,
-  to,
-  now = Date.now(),
-  timeZone = getLocalTimeZone(),
-  includeArchived = true,
-} = {}) {
-  const range = resolveUsageQuery({ period, from, to, now, timeZone });
-  const archivedSessionsDir = path.join(
-    path.dirname(sessionsDir),
-    ARCHIVED_SESSIONS_SOURCE_ROOT,
-  );
-
-  const roots = [
-    { sourceRoot: SESSIONS_SOURCE_ROOT, dir: sessionsDir },
-  ];
-  if (includeArchived) {
-    roots.push({
-      sourceRoot: ARCHIVED_SESSIONS_SOURCE_ROOT,
-      dir: archivedSessionsDir,
-    });
-  }
-
-  const entries = roots.flatMap((root) =>
-    iterRolloutFiles(root.dir).map((filePath) => ({
-      ...root,
-      filePath,
-      relpath: path.relative(root.dir, filePath).split(path.sep).join('/'),
-    })),
-  );
-
-  entries.sort((left, right) => left.filePath.localeCompare(right.filePath));
-
-  const summary = emptyUsageRow();
-  const dayMap = new Map();
-  const trendMap = new Map();
-  const modelMap = new Map();
-  let tokenEventCount = 0;
-
-  for (const entry of entries) {
-    const parser = new RolloutParser(
-      LOCAL_USAGE_COLLECTOR,
-      `${entry.sourceRoot}/${entry.relpath}`,
-    );
-    const input = fs.createReadStream(entry.filePath, { encoding: 'utf8' });
-    const rl = createInterface({ input, crlfDelay: Infinity });
-    let lineNo = 0;
-
-    try {
-      for await (const line of rl) {
-        lineNo += 1;
-        if (!line) continue;
-        const parsed = parser.processLine(lineNo, line);
-        for (const event of parsed.events) {
-          const eventDate = formatDateInTimeZone(event.timestamp, timeZone);
-          if (!isWithinDateRange(eventDate, range.from, range.to)) {
-            continue;
-          }
-
-          const usage = usageFromEvent(event);
-          tokenEventCount += 1;
-          accumulateUsage(summary, usage);
-
-          const currentDay = dayMap.get(eventDate) ?? {
-            date: eventDate,
-            eventCount: 0,
-            models: new Set(),
-            ...emptyUsageRow(),
-          };
-          currentDay.eventCount += 1;
-          currentDay.models.add(usage.model);
-          accumulateUsage(currentDay, usage);
-          dayMap.set(eventDate, currentDay);
-
-          const currentModel = modelMap.get(usage.model) ?? {
-            model: usage.model,
-            eventCount: 0,
-            ...emptyUsageRow(),
-          };
-          currentModel.eventCount += 1;
-          accumulateUsage(currentModel, usage);
-          modelMap.set(usage.model, currentModel);
-
-          if (isWithinDateRange(eventDate, range.trendFrom, range.trendTo)) {
-            const currentDate = trendMap.get(eventDate) ?? {
-              date: eventDate,
-              eventCount: 0,
-              ...emptyUsageRow(),
-            };
-            currentDate.eventCount += 1;
-            accumulateUsage(currentDate, usage);
-            trendMap.set(eventDate, currentDate);
-          }
-        }
-      }
-    } finally {
-      rl.close();
-    }
-  }
-
-  const days = [...dayMap.values()]
-    .sort((left, right) => left.date.localeCompare(right.date))
-    .map((row) => ({
-      ...row,
-      models: [...row.models].sort((left, right) => left.localeCompare(right)),
-    }));
-  const trend = materializeTrendRows(range, trendMap);
-  const byModel = [...modelMap.values()].sort((left, right) => {
-    if (right.totalTokens !== left.totalTokens) {
-      return right.totalTokens - left.totalTokens;
-    }
-    return left.model.localeCompare(right.model);
-  });
-
-  return {
-    scope: 'local-machine',
-    timezone: timeZone,
-    range,
-    sources: {
-      sessionsDir,
-      archivedSessionsDir,
-      includeArchived,
-    },
-    filesScanned: entries.length,
-    tokenEventCount,
-    summary,
-    days,
-    trend,
-    byModel,
-  };
-}
-
-function 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);
-  return files;
-}
-
-function emptyUsageRow() {
-  return {
-    inputTokens: 0,
-    cachedInputTokens: 0,
-    outputTokens: 0,
-    reasoningOutputTokens: 0,
-    totalTokens: 0,
-  };
-}
-
-function materializeTrendRows(range, trendMap) {
-  const rows = [...trendMap.values()].sort((left, right) =>
-    left.date.localeCompare(right.date),
-  );
-  if (rows.length === 0) {
-    return [];
-  }
-  if (!range.trendFrom || !range.trendTo || range.trendFrom > range.trendTo) {
-    return rows;
-  }
-  const materialized = [];
-  for (let date = range.trendFrom; date <= range.trendTo; date = addDays(date, 1)) {
-    materialized.push(
-      trendMap.get(date) ?? {
-        date,
-        eventCount: 0,
-        ...emptyUsageRow(),
-      },
-    );
-  }
-  return materialized;
-}
-
-function usageFromEvent(event) {
-  return {
-    model: event.model ?? '(unknown)',
-    inputTokens: numberOrZero(event.lastInputTokens),
-    cachedInputTokens: numberOrZero(event.lastCachedInputTokens),
-    outputTokens: numberOrZero(event.lastOutputTokens),
-    reasoningOutputTokens: numberOrZero(event.lastReasoningOutputTokens),
-    totalTokens: numberOrZero(event.lastTotalTokens),
-  };
-}
-
-function accumulateUsage(target, usage) {
-  target.inputTokens += usage.inputTokens;
-  target.cachedInputTokens += usage.cachedInputTokens;
-  target.outputTokens += usage.outputTokens;
-  target.reasoningOutputTokens += usage.reasoningOutputTokens;
-  target.totalTokens += usage.totalTokens;
-}
-
-function numberOrZero(value) {
-  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
-
-function formatDateInTimeZone(timestampMs, timeZone) {
-  const parts = new Intl.DateTimeFormat('en-US', {
-    timeZone,
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-  }).formatToParts(new Date(timestampMs));
-  const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
-  return `${values.year}-${values.month}-${values.day}`;
-}
-
-function normalizeDateString(value, label) {
-  if (!DATE_RE.test(String(value))) {
-    throw new Error(`${label} must be in YYYY-MM-DD format`);
-  }
-  const [yearRaw, monthRaw, dayRaw] = String(value).split('-');
-  const year = Number(yearRaw);
-  const month = Number(monthRaw);
-  const day = Number(dayRaw);
-  const normalized = new Date(Date.UTC(year, month - 1, day));
-  if (
-    Number.isNaN(normalized.getTime()) ||
-    normalized.getUTCFullYear() !== year ||
-    normalized.getUTCMonth() !== month - 1 ||
-    normalized.getUTCDate() !== day
-  ) {
-    throw new Error(`${label} must be a valid calendar date`);
-  }
-  return `${yearRaw}-${monthRaw}-${dayRaw}`;
-}
-
-function addDays(dateString, deltaDays) {
-  const [year, month, day] = dateString.split('-').map(Number);
-  const shifted = new Date(Date.UTC(year, month - 1, day + deltaDays));
-  const nextYear = shifted.getUTCFullYear();
-  const nextMonth = String(shifted.getUTCMonth() + 1).padStart(2, '0');
-  const nextDay = String(shifted.getUTCDate()).padStart(2, '0');
-  return `${nextYear}-${nextMonth}-${nextDay}`;
-}
-
-function isWithinDateRange(date, from, to) {
-  if (from && date < from) return false;
-  if (to && date > to) return false;
-  return true;
-}