@token-dashboard/codex-usage-uploader 0.1.0

package/src/cli.js

@@ -0,0 +1,596 @@
+import fs from 'node:fs';
+import { CodexUsageUploader } from './collector.js';
+import { identityIsBound, promptConfirm } from './auth.js';
+import { CLI_NAME, DEFAULT_CONFIG_FILE, PRODUCT_NAME } from './constants.js';
+import { findPackageRoot, installCurrentPackage } from './install.js';
+import { LaunchdServiceManager } from './launchd.js';
+import { formatStatusOutput, mergeRuntimeConfig } from './runtime-config.js';
+import { StateDb } from './state-db.js';
+
+const HELP_TEXT = `${PRODUCT_NAME}
+
+Usage:
+  ${CLI_NAME} init [--backend-url <url>] [--interval 30] [--yes] [--package-spec <spec>]
+  ${CLI_NAME} bind [--email <email>] [--employee-name <name>] [--employee-id <id>] [--yes]
+  ${CLI_NAME} clear [--yes]
+  ${CLI_NAME} start
+  ${CLI_NAME} stop
+  ${CLI_NAME} restart
+  ${CLI_NAME} status
+  ${CLI_NAME} logs [--lines 100]
+  ${CLI_NAME} uninstall
+
+Common options:
+  --config-file <path>       Runtime config path. Default: ${DEFAULT_CONFIG_FILE}
+  --backend-url <url>        Dashboard backend URL
+  --interval <seconds>       Scan interval in seconds
+  --codex-auth <path>        Codex auth.json path
+  --sessions-dir <path>      Codex rollout root directory
+  --state-db <path>          Local SQLite state DB path
+  --employee-id <id>         Bind employee ID
+  --email <email>            Bind employee email
+  --employee-name <name>     Bind employee name
+  --device-id <id>           Override device ID
+  --hostname <name>          Override hostname
+  --yes                      Skip interactive prompts
+  --package-spec <spec>      npm install spec used by init
+  --lines <n>                Number of log lines for service logs
+  -h, --help                 Show help
+`;
+
+class CliOperationalError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CliOperationalError';
+    this.showUsage = false;
+  }
+}
+
+export const cliDeps = {
+  findPackageRoot,
+  installCurrentPackage,
+  createUploader(runtime) {
+    return new CodexUsageUploader({
+      sessionsDir: runtime.sessionsDir,
+      stateDbPath: runtime.stateDbPath,
+      backendUrl: runtime.backendUrl,
+      intervalSeconds: runtime.intervalSeconds,
+      codexAuthPath: runtime.codexAuthPath,
+    });
+  },
+  createServiceManager(runtime) {
+    return new LaunchdServiceManager(runtime);
+  },
+};
+
+export function parseCliArgs(argv) {
+  const options = {
+    configFile: DEFAULT_CONFIG_FILE,
+    interval: undefined,
+    yes: false,
+    lines: 100,
+  };
+  const positionals = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('-')) {
+      positionals.push(token);
+      continue;
+    }
+
+    if (token === '-h' || token === '--help') {
+      options.help = true;
+      continue;
+    }
+    if (token === '--yes') {
+      options.yes = true;
+      continue;
+    }
+
+    const [key, inlineValue] = token.split('=', 2);
+    const takesValue = new Set([
+      '--config-file',
+      '--backend-url',
+      '--interval',
+      '--codex-auth',
+      '--sessions-dir',
+      '--state-db',
+      '--employee-id',
+      '--email',
+      '--employee-name',
+      '--device-id',
+      '--hostname',
+      '--package-spec',
+      '--lines',
+    ]);
+    if (!takesValue.has(key)) {
+      throw new Error(`Unknown argument: ${token}`);
+    }
+    const value = inlineValue ?? argv[++index];
+    if (value == null || value.startsWith('-')) {
+      throw new Error(`Missing value for ${key}`);
+    }
+    assignOption(options, key, value);
+  }
+
+  return {
+    command: positionals[0] ?? null,
+    subcommand: positionals[1] ?? null,
+    extraPositionals: positionals.slice(2),
+    options,
+  };
+}
+
+function assignOption(options, key, value) {
+  switch (key) {
+    case '--config-file':
+      options.configFile = value;
+      break;
+    case '--backend-url':
+      options.backendUrl = value;
+      break;
+    case '--interval':
+      options.interval = parsePositiveInt(value, '--interval');
+      break;
+    case '--codex-auth':
+      options.codexAuthPath = value;
+      break;
+    case '--sessions-dir':
+      options.sessionsDir = value;
+      break;
+    case '--state-db':
+      options.stateDbPath = value;
+      break;
+    case '--employee-id':
+      options.employeeId = value;
+      break;
+    case '--email':
+      options.employeeEmail = value;
+      break;
+    case '--employee-name':
+      options.employeeName = value;
+      break;
+    case '--device-id':
+      options.deviceId = value;
+      break;
+    case '--hostname':
+      options.hostname = value;
+      break;
+    case '--package-spec':
+      options.packageSpec = value;
+      break;
+    case '--lines':
+      options.lines = parsePositiveInt(value, '--lines');
+      break;
+    default:
+      throw new Error(`Unknown argument: ${key}`);
+  }
+}
+
+function parsePositiveInt(value, label) {
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return parsed;
+}
+
+function runtimeOverrides(options) {
+  const overrides = {};
+  if (options.backendUrl !== undefined) overrides.backendUrl = options.backendUrl;
+  if (options.interval !== undefined) overrides.intervalSeconds = options.interval;
+  if (options.codexAuthPath !== undefined) overrides.codexAuthPath = options.codexAuthPath;
+  if (options.sessionsDir !== undefined) overrides.sessionsDir = options.sessionsDir;
+  if (options.stateDbPath !== undefined) overrides.stateDbPath = options.stateDbPath;
+  return overrides;
+}
+
+function identityOverrides(options) {
+  const overrides = {};
+  if (options.employeeId !== undefined) overrides.employeeId = options.employeeId;
+  if (options.employeeEmail !== undefined) overrides.employeeEmail = options.employeeEmail;
+  if (options.employeeName !== undefined) overrides.employeeName = options.employeeName;
+  if (options.deviceId !== undefined) overrides.deviceId = options.deviceId;
+  if (options.hostname !== undefined) overrides.hostname = options.hostname;
+  return overrides;
+}
+
+function assertBoundIdentity(uploader) {
+  if (!identityIsBound(uploader.identity)) {
+    throw new CliOperationalError(
+      'No employee identity is bound yet. Run `codex-usage-uploader bind` or rerun `init` with --email.',
+    );
+  }
+}
+
+function printUsage() {
+  console.log(HELP_TEXT);
+}
+
+function validateCommandShape(command, subcommand, extraPositionals) {
+  if (subcommand) {
+    throw new Error(`Unexpected subcommand for ${command}: ${subcommand}`);
+  }
+  if (extraPositionals.length > 0) {
+    throw new Error(`Unexpected extra arguments: ${extraPositionals.join(' ')}`);
+  }
+}
+
+function printIdentity(identity) {
+  console.log('Identity binding:');
+  console.log(`  collectorId: ${identity.collectorId}`);
+  console.log(`  employeeEmail: ${identity.employeeEmail ?? '-'}`);
+  console.log(`  employeeName: ${identity.employeeName ?? '-'}`);
+  console.log(`  employeeId: ${identity.employeeId ?? '-'}`);
+  console.log(`  deviceId: ${identity.deviceId ?? '-'}`);
+  console.log(`  hostname: ${identity.hostname ?? '-'}`);
+}
+
+function tailFile(filePath, lines) {
+  if (!fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, 'utf8');
+  return content
+    .split(/\r?\n/)
+    .filter((line, index, array) => !(index === array.length - 1 && line === ''))
+    .slice(-lines);
+}
+
+async function bindIdentity(uploader, options) {
+  const overrides = identityOverrides(options);
+  if (options.yes) {
+    const identity = uploader.configureIdentityWithDefaults(overrides);
+    assertBoundIdentity(uploader);
+    return identity;
+  }
+  const identity = await uploader.configureIdentityInteractive(overrides);
+  assertBoundIdentity(uploader);
+  return identity;
+}
+
+function formatDuration(durationMs) {
+  const seconds = Math.max(0, Math.round(durationMs / 1000));
+  return `${seconds}s`;
+}
+
+function printCatchUpProgress(event) {
+  switch (event.phase) {
+    case 'start':
+      console.log(
+        `[catch-up] start files=${event.totalFiles} queued_batches=${
+          event.bufferingBatchCount +
+          event.pendingBatchCount +
+          event.retryingBatchCount
+        } queued_events=${event.queuedEvents}`,
+      );
+      return;
+    case 'file':
+      console.log(
+        `[catch-up] file ${event.filesProcessed}/${event.totalFiles} current=${event.file} events=${event.eventsParsed} queued_batches=${
+          event.bufferingBatchCount +
+          event.pendingBatchCount +
+          event.retryingBatchCount
+        } queued_events=${event.queuedEvents}`,
+      );
+      return;
+    case 'upload':
+      console.log(
+        `[catch-up] uploaded_batches=${event.batchesUploaded} last_batch=${event.batchKey} remaining_batches=${
+          event.bufferingBatchCount +
+          event.pendingBatchCount +
+          event.retryingBatchCount
+        } remaining_events=${event.queuedEvents}`,
+      );
+      return;
+    case 'done':
+      console.log(
+        `[catch-up] complete files=${event.filesProcessed}/${event.totalFiles} events=${event.eventsParsed} uploaded_batches=${event.batchesUploaded} remaining_batches=${event.remainingQueuedBatches} remaining_events=${event.remainingQueuedEvents} duration=${formatDuration(event.durationMs)}`,
+      );
+      return;
+    case 'error':
+      console.error(
+        `[catch-up] failed stage=${event.stage} message=${event.message} remaining_batches=${
+          event.bufferingBatchCount +
+          event.pendingBatchCount +
+          event.retryingBatchCount
+        } remaining_events=${event.queuedEvents}`,
+      );
+      return;
+  }
+}
+
+function wrapCatchUpFailure(error) {
+  return new CliOperationalError(
+    `Foreground catch-up failed: ${
+      error instanceof Error ? error.message : String(error)
+    }`,
+  );
+}
+
+async function runInit(options) {
+  let runtime = mergeRuntimeConfig(options.configFile, runtimeOverrides(options));
+  if (!runtime.backendUrl) {
+    throw new Error(
+      '--backend-url is required for init unless already configured in config.json',
+    );
+  }
+
+  runtime = cliDeps.installCurrentPackage(runtime, {
+    packageRoot: cliDeps.findPackageRoot(),
+    packageSpec: options.packageSpec,
+    nodePath: process.execPath,
+  });
+
+  const manager = cliDeps.createServiceManager(runtime);
+  manager.stop();
+
+  const uploader = cliDeps.createUploader(runtime);
+  try {
+    const identity = await bindIdentity(uploader, options);
+    console.log(`${PRODUCT_NAME} install is ready.`);
+    console.log(`Backend: ${runtime.backendUrl}`);
+    console.log(`Install root: ${runtime.installRoot}`);
+    console.log(`Config file: ${runtime.configFile}`);
+    printIdentity(identity);
+    console.log('Starting foreground historical catch-up.');
+
+    try {
+      await uploader.runForegroundCatchUp({
+        onProgress: printCatchUpProgress,
+      });
+    } catch (error) {
+      throw wrapCatchUpFailure(error);
+    }
+
+    manager.start();
+    console.log(`${PRODUCT_NAME} initialized and started.`);
+    console.log(`Use \`${CLI_NAME} status\` to check the local service.`);
+  } finally {
+    uploader.close();
+  }
+}
+
+async function runBind(options) {
+  const runtime = mergeRuntimeConfig(options.configFile, runtimeOverrides(options));
+  const uploader = cliDeps.createUploader(runtime);
+  try {
+    const identity = await bindIdentity(uploader, options);
+    printIdentity(identity);
+    if (await restartRunningServiceIfNeeded(runtime)) {
+      console.log(
+        'Background service restarted to apply the updated identity.',
+      );
+    }
+  } finally {
+    uploader.close();
+  }
+}
+
+async function runInternalWorker(options) {
+  const runtime = mergeRuntimeConfig(options.configFile, runtimeOverrides(options));
+  const uploader = cliDeps.createUploader(runtime);
+  try {
+    assertBoundIdentity(uploader);
+    console.log(
+      `[run] backend=${runtime.backendUrl ?? '-'} interval=${runtime.intervalSeconds}s sessions_dir=${runtime.sessionsDir}`,
+    );
+    await uploader.watch();
+  } finally {
+    uploader.close();
+  }
+}
+
+function loadQueueStats(stateDbPath) {
+  if (!fs.existsSync(stateDbPath)) {
+    return {
+      bufferingBatchCount: 0,
+      pendingBatchCount: 0,
+      retryingBatchCount: 0,
+      queuedSessions: 0,
+      queuedTurns: 0,
+      queuedEvents: 0,
+      oldestPendingAgeSeconds: null,
+    };
+  }
+  const stateDb = new StateDb(stateDbPath);
+  try {
+    return stateDb.getQueueStats();
+  } finally {
+    stateDb.close();
+  }
+}
+
+function printStatus(runtime, status) {
+  const payload = {
+    ...formatStatusOutput(runtime, status),
+    ...loadQueueStats(runtime.stateDbPath),
+  };
+  const lines = [
+    ['Config exists', payload.configExists ? 'yes' : 'no'],
+    ['Loaded', payload.loaded ? 'yes' : 'no'],
+    ['Running', payload.running ? 'yes' : 'no'],
+    ['PID', payload.pid ?? '-'],
+    ['State', payload.state ?? '-'],
+    ['Last exit code', payload.lastExitCode ?? '-'],
+    ['Backend URL', payload.backendUrl ?? '-'],
+    ['Interval', `${payload.intervalSeconds}s`],
+    ['Buffering batches', payload.bufferingBatchCount],
+    ['Pending batches', payload.pendingBatchCount],
+    ['Retrying batches', payload.retryingBatchCount],
+    ['Queued sessions', payload.queuedSessions],
+    ['Queued turns', payload.queuedTurns],
+    ['Queued events', payload.queuedEvents],
+    [
+      'Oldest pending age',
+      payload.oldestPendingAgeSeconds == null
+        ? '-'
+        : `${payload.oldestPendingAgeSeconds}s`,
+    ],
+    ['Config file', payload.configFile],
+    ['State DB', payload.stateDbPath],
+    ['Stdout log', payload.stdoutLogPath],
+    ['Stderr log', payload.stderrLogPath],
+    ['Plist', payload.plistPath],
+    ['Label', payload.label],
+  ];
+  for (const [label, value] of lines) {
+    console.log(`${label}: ${value}`);
+  }
+}
+
+function ensureInitialized(runtime) {
+  if (!fs.existsSync(runtime.configFile) || !runtime.entryFile) {
+    throw new CliOperationalError(
+      `Uploader is not initialized yet. Run \`${CLI_NAME} init\` first.`,
+    );
+  }
+}
+
+async function runClear(options) {
+  const runtime = mergeRuntimeConfig(options.configFile, runtimeOverrides(options));
+  ensureInitialized(runtime);
+
+  const manager = cliDeps.createServiceManager(runtime);
+  const status = manager.status();
+  if (status.running) {
+    throw new CliOperationalError(
+      `Background service is still running. Stop it first with \`${CLI_NAME} stop\`.`,
+    );
+  }
+
+  if (!options.yes) {
+    const confirmed = await promptConfirm(
+      'Clear local backfill state and queued uploads?',
+      false,
+    );
+    if (!confirmed) {
+      console.log('Clear cancelled.');
+      return;
+    }
+  }
+
+  const uploader = cliDeps.createUploader(runtime);
+  try {
+    uploader.resetBackfillState();
+  } finally {
+    uploader.close();
+  }
+
+  console.log('Local backfill state has been cleared.');
+  console.log(
+    `Run \`${CLI_NAME} init\` when you want to backfill history again.`,
+  );
+}
+
+async function restartRunningServiceIfNeeded(runtime) {
+  if (process.platform !== 'darwin') return false;
+  if (!fs.existsSync(runtime.configFile) || !runtime.entryFile) return false;
+  const manager = cliDeps.createServiceManager(runtime);
+  let status;
+  try {
+    status = manager.status();
+  } catch {
+    return false;
+  }
+  if (!status.running) return false;
+  manager.restart();
+  return true;
+}
+
+function runLifecycleCommand(action, options) {
+  const runtime = mergeRuntimeConfig(options.configFile, runtimeOverrides(options));
+  const manager = cliDeps.createServiceManager(runtime);
+
+  switch (action) {
+    case 'start':
+      ensureInitialized(runtime);
+      manager.start();
+      console.log(`Service started: ${runtime.launchdLabel}`);
+      return;
+    case 'stop':
+      manager.stop();
+      console.log(`Service stopped: ${runtime.launchdLabel}`);
+      return;
+    case 'restart':
+      ensureInitialized(runtime);
+      manager.restart();
+      console.log(`Service restarted: ${runtime.launchdLabel}`);
+      return;
+    case 'status':
+      printStatus(runtime, manager.status());
+      return;
+    case 'logs': {
+      const stdoutLines = tailFile(runtime.stdoutLogPath, options.lines);
+      const stderrLines = tailFile(runtime.stderrLogPath, options.lines);
+      console.log(`== stdout (${runtime.stdoutLogPath}) ==`);
+      console.log(stdoutLines.length ? stdoutLines.join('\n') : '(empty)');
+      console.log(`== stderr (${runtime.stderrLogPath}) ==`);
+      console.log(stderrLines.length ? stderrLines.join('\n') : '(empty)');
+      return;
+    }
+    case 'uninstall':
+      manager.uninstall();
+      fs.rmSync(runtime.installRoot, { recursive: true, force: true });
+      console.log(`${PRODUCT_NAME} uninstalled from ${runtime.installRoot}`);
+      return;
+    default:
+      throw new Error(`Unknown lifecycle command: ${action ?? '(empty)'}`);
+  }
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  try {
+    const { command, subcommand, extraPositionals, options } = parseCliArgs(argv);
+    if (!command || options.help) {
+      printUsage();
+      return 0;
+    }
+
+    const knownCommands = new Set([
+      'init',
+      'bind',
+      'clear',
+      'start',
+      'stop',
+      'restart',
+      'status',
+      'logs',
+      'uninstall',
+      'run',
+    ]);
+    if (!knownCommands.has(command)) {
+      throw new Error(`Unknown command: ${command}`);
+    }
+
+    validateCommandShape(command, subcommand, extraPositionals);
+
+    switch (command) {
+      case 'init':
+        await runInit(options);
+        return 0;
+      case 'bind':
+        await runBind(options);
+        return 0;
+      case 'clear':
+        await runClear(options);
+        return 0;
+      case 'run':
+        await runInternalWorker(options);
+        return 0;
+      case 'start':
+      case 'stop':
+      case 'restart':
+      case 'status':
+      case 'logs':
+      case 'uninstall':
+        runLifecycleCommand(command, options);
+        return 0;
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    if (error?.showUsage !== false) {
+      console.error(`Run \`${CLI_NAME} --help\` for usage.`);
+    }
+    return 1;
+  }
+}