@token-dashboard/codex-usage-uploader 0.1.0

package/src/install.js

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+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';
+
+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);
+}

package/src/launchd.js

@@ -0,0 +1,151 @@
+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)'}`);
+    }
+    fs.mkdirSync(path.dirname(this.runtime.plistPath), { recursive: true });
+    fs.mkdirSync(path.dirname(this.runtime.stdoutLogPath), { recursive: true });
+    fs.writeFileSync(this.runtime.plistPath, buildLaunchdPlist(this.runtime));
+  }
+
+  start() {
+    this.ensurePlist();
+    this.stop();
+    this.run(['launchctl', 'bootstrap', this.domainTarget(), this.runtime.plistPath]);
+    this.run(['launchctl', 'kickstart', '-k', this.serviceTarget()], { check: false });
+  }
+
+  stop() {
+    this.ensureMacos();
+    this.run(['launchctl', 'bootout', this.domainTarget(), this.runtime.plistPath], { 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 (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/parser.js

@@ -0,0 +1,180 @@
+import { computeEventUid, deriveRepoName, isoToEpochMs, stableStringify } from './utils.js';
+
+export class RolloutParser {
+  constructor(collectorIdentity, relpath, initialState = {}) {
+    this.collectorIdentity = collectorIdentity;
+    this.relpath = relpath;
+    this.currentSession = initialState.current_session ?? null;
+    this.currentTurn = initialState.current_turn ?? null;
+  }
+
+  exportState() {
+    return {
+      current_session: this.currentSession,
+      current_turn: this.currentTurn,
+    };
+  }
+
+  normalizeSession(payload) {
+    if (!payload?.id) return null;
+    const git = payload.git && typeof payload.git === 'object' ? payload.git : {};
+    const cwd = payload.cwd ?? null;
+    const repositoryUrl = git.repository_url ?? null;
+    return {
+      sessionId: String(payload.id),
+      sessionTimestamp: isoToEpochMs(payload.timestamp),
+      cwd,
+      originator: payload.originator ?? null,
+      source: payload.source ?? null,
+      cliVersion: payload.cli_version ?? null,
+      modelProvider: payload.model_provider ?? null,
+      repoName: deriveRepoName(repositoryUrl, cwd),
+      gitBranch: git.branch ?? null,
+      gitCommitHash: git.commit_hash ?? null,
+      repositoryUrl,
+    };
+  }
+
+  normalizeTurn(payload, timestampMs) {
+    const turnId = payload?.turn_id;
+    const sessionId = this.currentSession?.sessionId;
+    if (!turnId || !sessionId) return null;
+    const sandbox = payload.sandbox_policy && typeof payload.sandbox_policy === 'object'
+      ? payload.sandbox_policy
+      : {};
+    const writableRoots = Array.isArray(sandbox.writable_roots) ? sandbox.writable_roots : null;
+    const collaborationMode = payload.collaboration_mode && typeof payload.collaboration_mode === 'object'
+      ? payload.collaboration_mode.mode
+      : null;
+    return {
+      turnId: String(turnId),
+      sessionId: String(sessionId),
+      eventTimestamp: timestampMs,
+      cwd: payload.cwd ?? null,
+      currentDate: payload.current_date ?? null,
+      timezone: payload.timezone ?? null,
+      approvalPolicy: payload.approval_policy ?? null,
+      sandboxPolicyType: sandbox.type ?? null,
+      sandboxNetworkAccess: sandbox.network_access ?? null,
+      sandboxWritableRootsJson: writableRoots ? stableStringify(writableRoots) : null,
+      sandboxPolicyJson: Object.keys(sandbox).length ? stableStringify(sandbox) : null,
+      model: payload.model ?? null,
+      personality: payload.personality ?? null,
+      collaborationMode: collaborationMode ?? null,
+      effort: payload.effort ?? null,
+      summary: payload.summary ?? null,
+      truncationPolicyJson: payload.truncation_policy != null
+        ? stableStringify(payload.truncation_policy)
+        : null,
+    };
+  }
+
+  normalizeTokenEvent(payload, timestampMs, lineNo) {
+    if (!this.currentSession || timestampMs == null) return null;
+    const info = payload?.info;
+    if (!info || typeof info !== 'object') return null;
+    const totalUsage = info.total_token_usage && typeof info.total_token_usage === 'object'
+      ? info.total_token_usage
+      : {};
+    const lastUsage = info.last_token_usage && typeof info.last_token_usage === 'object'
+      ? info.last_token_usage
+      : {};
+    const rateLimits = payload.rate_limits && typeof payload.rate_limits === 'object'
+      ? payload.rate_limits
+      : {};
+    const primary = rateLimits.primary && typeof rateLimits.primary === 'object' ? rateLimits.primary : {};
+    const secondary = rateLimits.secondary && typeof rateLimits.secondary === 'object' ? rateLimits.secondary : {};
+    const session = this.currentSession;
+    const turn = this.currentTurn ?? {};
+    return {
+      eventUid: computeEventUid(this.collectorIdentity.collectorId, this.relpath, lineNo),
+      sessionId: session.sessionId,
+      turnId: turn.turnId ?? null,
+      sourceFileRelpath: this.relpath,
+      lineNo,
+      timestamp: timestampMs,
+      model: turn.model ?? null,
+      cwd: turn.cwd ?? session.cwd ?? null,
+      timezone: turn.timezone ?? null,
+      approvalPolicy: turn.approvalPolicy ?? null,
+      sandboxPolicyType: turn.sandboxPolicyType ?? null,
+      source: session.source ?? null,
+      originator: session.originator ?? null,
+      cliVersion: session.cliVersion ?? null,
+      repositoryUrl: session.repositoryUrl ?? null,
+      repoName: session.repoName ?? null,
+      gitBranch: session.gitBranch ?? null,
+      gitCommitHash: session.gitCommitHash ?? null,
+      totalInputTokens: totalUsage.input_tokens ?? null,
+      totalCachedInputTokens: totalUsage.cached_input_tokens ?? null,
+      totalOutputTokens: totalUsage.output_tokens ?? null,
+      totalReasoningOutputTokens: totalUsage.reasoning_output_tokens ?? null,
+      totalTokens: totalUsage.total_tokens ?? null,
+      lastInputTokens: lastUsage.input_tokens ?? null,
+      lastCachedInputTokens: lastUsage.cached_input_tokens ?? null,
+      lastOutputTokens: lastUsage.output_tokens ?? null,
+      lastReasoningOutputTokens: lastUsage.reasoning_output_tokens ?? null,
+      lastTotalTokens: lastUsage.total_tokens ?? null,
+      modelContextWindow: info.model_context_window ?? null,
+      rateLimitPlanType: rateLimits.plan_type ?? null,
+      primaryUsedPercent: primary.used_percent ?? null,
+      primaryWindowMinutes: primary.window_minutes ?? null,
+      primaryResetsAt: primary.resets_at ?? null,
+      secondaryUsedPercent: secondary.used_percent ?? null,
+      secondaryWindowMinutes: secondary.window_minutes ?? null,
+      secondaryResetsAt: secondary.resets_at ?? null,
+      credits: normalizeCredits(rateLimits.credits),
+      rawRateLimitsJson: Object.keys(rateLimits).length ? stableStringify(rateLimits) : null,
+    };
+  }
+
+  processLine(lineNo, line) {
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      return { sessions: [], turns: [], events: [] };
+    }
+
+    const recordType = record.type;
+    const payload = record.payload ?? {};
+    const timestampMs = isoToEpochMs(record.timestamp);
+    const sessions = [];
+    const turns = [];
+    const events = [];
+
+    if (recordType === 'session_meta') {
+      const normalized = this.normalizeSession(payload);
+      if (normalized) {
+        this.currentSession = normalized;
+        sessions.push(normalized);
+      }
+    } else if (recordType === 'turn_context') {
+      const normalized = this.normalizeTurn(payload, timestampMs);
+      if (normalized) {
+        this.currentTurn = normalized;
+        turns.push(normalized);
+      }
+    } else if (recordType === 'event_msg' && payload.type === 'token_count') {
+      const normalized = this.normalizeTokenEvent(payload, timestampMs, lineNo);
+      if (normalized) {
+        events.push(normalized);
+      }
+    }
+
+    return { sessions, turns, events };
+  }
+}
+
+function normalizeCredits(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (value && typeof value === 'object') {
+    const balance = value.balance;
+    if (typeof balance === 'number' && Number.isFinite(balance)) {
+      return balance;
+    }
+  }
+  return null;
+}

package/src/runtime-config.js

@@ -0,0 +1,142 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  CLI_NAME,
+  DEFAULT_APP_ROOT,
+  DEFAULT_BACKEND_URL,
+  DEFAULT_CODEX_AUTH_PATH,
+  DEFAULT_CONFIG_FILE,
+  DEFAULT_CURRENT_APP_DIR,
+  DEFAULT_HOME_BIN_LINK,
+  DEFAULT_INSTALL_ROOT,
+  DEFAULT_LAUNCHD_LABEL,
+  DEFAULT_LOCAL_BIN_DIR,
+  DEFAULT_LOCAL_BIN_PATH,
+  DEFAULT_LOG_DIR,
+  DEFAULT_PLIST_PATH,
+  DEFAULT_SESSIONS_DIR,
+  DEFAULT_STATE_DB,
+  DEFAULT_STDERR_LOG_PATH,
+  DEFAULT_STDOUT_LOG_PATH,
+  STATUS_ONLINE_THRESHOLD_SECONDS,
+} from './constants.js';
+import { stableStringify } from './utils.js';
+
+export function defaultRuntimeConfig(configFile = DEFAULT_CONFIG_FILE) {
+  const installRoot = path.dirname(configFile);
+  const appRoot = path.join(installRoot, 'app');
+  const currentAppDir = path.join(appRoot, 'current');
+  return {
+    configFile,
+    installRoot,
+    appRoot,
+    currentAppDir,
+    backendUrl: DEFAULT_BACKEND_URL,
+    intervalSeconds: 30,
+    codexAuthPath: DEFAULT_CODEX_AUTH_PATH,
+    sessionsDir: DEFAULT_SESSIONS_DIR,
+    stateDbPath: path.join(installRoot, path.basename(DEFAULT_STATE_DB)),
+    nodePath: process.execPath,
+    entryFile: '',
+    packageSpec: '',
+    localBinDir: path.join(installRoot, 'bin'),
+    localBinPath: path.join(installRoot, 'bin', CLI_NAME),
+    homeBinLink: DEFAULT_HOME_BIN_LINK,
+    stdoutLogPath: path.join(installRoot, 'logs', path.basename(DEFAULT_STDOUT_LOG_PATH)),
+    stderrLogPath: path.join(installRoot, 'logs', path.basename(DEFAULT_STDERR_LOG_PATH)),
+    launchdLabel: DEFAULT_LAUNCHD_LABEL,
+    plistPath: DEFAULT_PLIST_PATH,
+  };
+}
+
+export function loadRuntimeConfig(configFile = DEFAULT_CONFIG_FILE) {
+  const runtime = defaultRuntimeConfig(configFile);
+  try {
+    const payload = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    if (!payload || typeof payload !== 'object') return runtime;
+    return normalizeRuntimeConfig({ ...runtime, ...payload, configFile });
+  } catch {
+    return runtime;
+  }
+}
+
+export function normalizeRuntimeConfig(runtime) {
+  const installRoot = runtime.installRoot || DEFAULT_INSTALL_ROOT;
+  const appRoot = runtime.appRoot || path.join(installRoot, 'app');
+  const currentAppDir = runtime.currentAppDir || path.join(appRoot, 'current');
+  const localBinDir = runtime.localBinDir || DEFAULT_LOCAL_BIN_DIR;
+  return {
+    ...runtime,
+    configFile: runtime.configFile || DEFAULT_CONFIG_FILE,
+    installRoot,
+    appRoot,
+    currentAppDir,
+    backendUrl: runtime.backendUrl?.trim() ? runtime.backendUrl.replace(/\/+$/, '') : null,
+    intervalSeconds: Number(runtime.intervalSeconds) || 30,
+    codexAuthPath: runtime.codexAuthPath || DEFAULT_CODEX_AUTH_PATH,
+    sessionsDir: runtime.sessionsDir || DEFAULT_SESSIONS_DIR,
+    stateDbPath: runtime.stateDbPath || path.join(installRoot, 'state.sqlite'),
+    nodePath: runtime.nodePath || process.execPath,
+    entryFile: runtime.entryFile || '',
+    packageSpec: runtime.packageSpec || '',
+    localBinDir,
+    localBinPath: runtime.localBinPath || path.join(localBinDir, CLI_NAME),
+    homeBinLink: runtime.homeBinLink || DEFAULT_HOME_BIN_LINK,
+    stdoutLogPath: runtime.stdoutLogPath || path.join(installRoot, 'logs', 'stdout.log'),
+    stderrLogPath: runtime.stderrLogPath || path.join(installRoot, 'logs', 'stderr.log'),
+    launchdLabel: runtime.launchdLabel || DEFAULT_LAUNCHD_LABEL,
+    plistPath: runtime.plistPath || DEFAULT_PLIST_PATH,
+  };
+}
+
+export function saveRuntimeConfig(runtime) {
+  const normalized = normalizeRuntimeConfig(runtime);
+  fs.mkdirSync(path.dirname(normalized.configFile), { recursive: true });
+  fs.mkdirSync(path.dirname(normalized.stdoutLogPath), { recursive: true });
+  fs.writeFileSync(normalized.configFile, `${stableStringify({
+    backendUrl: normalized.backendUrl,
+    intervalSeconds: normalized.intervalSeconds,
+    codexAuthPath: normalized.codexAuthPath,
+    sessionsDir: normalized.sessionsDir,
+    stateDbPath: normalized.stateDbPath,
+    installRoot: normalized.installRoot,
+    appRoot: normalized.appRoot,
+    currentAppDir: normalized.currentAppDir,
+    nodePath: normalized.nodePath,
+    entryFile: normalized.entryFile,
+    packageSpec: normalized.packageSpec,
+    localBinDir: normalized.localBinDir,
+    localBinPath: normalized.localBinPath,
+    homeBinLink: normalized.homeBinLink,
+    stdoutLogPath: normalized.stdoutLogPath,
+    stderrLogPath: normalized.stderrLogPath,
+    launchdLabel: normalized.launchdLabel,
+    plistPath: normalized.plistPath,
+  })}\n`);
+  return normalized;
+}
+
+export function mergeRuntimeConfig(configFile, overrides = {}) {
+  const base = loadRuntimeConfig(configFile);
+  return normalizeRuntimeConfig({ ...base, ...overrides, configFile });
+}
+
+export function formatStatusOutput(runtime, status) {
+  return {
+    configExists: fs.existsSync(runtime.configFile),
+    loaded: status.loaded,
+    running: status.running,
+    pid: status.pid,
+    state: status.state,
+    lastExitCode: status.lastExitCode,
+    backendUrl: runtime.backendUrl,
+    intervalSeconds: runtime.intervalSeconds,
+    configFile: runtime.configFile,
+    stateDbPath: runtime.stateDbPath,
+    stdoutLogPath: runtime.stdoutLogPath,
+    stderrLogPath: runtime.stderrLogPath,
+    plistPath: runtime.plistPath,
+    label: runtime.launchdLabel,
+    onlineThresholdSeconds: STATUS_ONLINE_THRESHOLD_SECONDS,
+  };
+}