@kodo/agent-meter 1.0.0

package/README.md

@@ -0,0 +1,37 @@
+# agent-meter
+
+CLI tool for managing multiple Codex OAuth accounts and checking their rate limits / usage.
+
+## Install
+
+```bash
+pnpm install
+```
+
+## Usage
+
+```bash
+# Add a new account (opens browser for OAuth login, then auto-checks usage)
+pnpm dev add
+
+# List all accounts with real-time usage check
+pnpm dev list
+
+# Remove an account by email
+pnpm dev delete <email>
+```
+
+## How it works
+
+- `add` creates an isolated `CODEX_HOME` directory, runs `codex login`, then immediately checks usage
+- `list` concurrently checks all accounts via the OAuth usage API and displays a table with progress bars
+- `delete` removes the account and its `CODEX_HOME` directory
+- If a token expires during `list`, you'll be prompted to re-login on the spot
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Output raw JSON |
+| `--verbose` | Enable verbose logging |
+| `--data-dir <path>` | Override the default `.data` directory |

package/dist/cli.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import readline from 'node:readline';
+import { Command } from 'commander';
+import { createCodexHome, createDataPaths, ensureDataPaths, makeId, markLastUsed, nowIso, normalizeAccount, readStore, removeAccountFromStore, resolveAccountRef, updateAccount, writeStore, } from './core/accounts.js';
+import { ensureCodexInstalled, loadCredentials, runCodexLogin } from './core/auth.js';
+import { printJson, renderAccountsTable } from './core/output.js';
+import { checkAccount } from './core/usage.js';
+function resolveDataDir(opts) {
+    if (!opts.dataDir)
+        return `${process.cwd()}/.data`;
+    const resolved = opts.dataDir.startsWith('/') ? opts.dataDir : `${process.cwd()}/${opts.dataDir}`;
+    return fs.existsSync(resolved) ? fs.realpathSync(resolved) : resolved;
+}
+function getStore(opts) {
+    const dataDir = resolveDataDir(opts);
+    const paths = createDataPaths(dataDir);
+    ensureDataPaths(paths);
+    return {
+        paths,
+        store: readStore(paths),
+    };
+}
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+const program = new Command();
+program
+    .name('agent-meter')
+    .description('Multi-account Codex OAuth usage checker')
+    .option('--json', 'output JSON')
+    .option('--verbose', 'enable verbose logging')
+    .option('--data-dir <path>', 'override .data directory');
+program
+    .command('add')
+    .description('add a new account via codex login')
+    .action(async () => {
+    const opts = program.opts();
+    const { paths, store } = getStore(opts);
+    ensureCodexInstalled();
+    const accountId = makeId();
+    const codexHome = createCodexHome(paths, accountId);
+    runCodexLogin(codexHome, Boolean(opts.verbose));
+    const credentials = loadCredentials(codexHome);
+    const label = credentials.email || credentials.accountId || accountId;
+    const account = markLastUsed(normalizeAccount({
+        id: accountId,
+        label,
+        email: credentials.email,
+        accountId: credentials.accountId,
+        codexHome,
+        createdAt: nowIso(),
+        lastUsedAt: nowIso(),
+    }));
+    let nextStore = updateAccount(store, account, { makeDefault: store.accounts.length === 0 });
+    writeStore(paths, nextStore);
+    process.stdout.write(`\n✓ Added account '${account.email || account.label}'.\n`);
+    process.stdout.write(`\nChecking usage...\n`);
+    const checked = await checkAccount(account);
+    const checkedAccount = markLastUsed(normalizeAccount({
+        ...checked.account,
+        lastCheck: checked.result,
+    }), nowIso());
+    nextStore = updateAccount(nextStore, checkedAccount);
+    writeStore(paths, nextStore);
+    if (opts.json) {
+        printJson({ accounts: nextStore.accounts });
+        return;
+    }
+    process.stdout.write(`\n${renderAccountsTable(nextStore)}\n`);
+});
+program
+    .command('list')
+    .description('check and list all accounts')
+    .action(async () => {
+    const opts = program.opts();
+    const { paths, store } = getStore(opts);
+    if (store.accounts.length === 0) {
+        if (opts.json) {
+            printJson({ accounts: [] });
+        }
+        else {
+            process.stdout.write(`${renderAccountsTable(store)}\n`);
+        }
+        return;
+    }
+    process.stdout.write('Checking all accounts...\n');
+    const results = await Promise.all(store.accounts.map(account => checkAccount(account)));
+    let nextStore = store;
+    for (const checked of results) {
+        const nextAccount = markLastUsed(normalizeAccount({
+            ...checked.account,
+            lastCheck: checked.result,
+        }), nowIso());
+        nextStore = updateAccount(nextStore, nextAccount);
+    }
+    writeStore(paths, nextStore);
+    const expired = nextStore.accounts.filter(a => a.lastCheck && !a.lastCheck.ok && a.lastCheck.error?.includes('Unauthorized'));
+    if (expired.length > 0 && !opts.json) {
+        process.stdout.write(`\n${renderAccountsTable(nextStore)}\n\n`);
+        for (const account of expired) {
+            const yes = await confirm(`⚠ Account '${account.email || account.label}' token expired. Re-login? (y/N) `);
+            if (!yes)
+                continue;
+            ensureCodexInstalled();
+            runCodexLogin(account.codexHome, Boolean(opts.verbose));
+            const credentials = loadCredentials(account.codexHome);
+            const refreshed = markLastUsed(normalizeAccount({
+                ...account,
+                email: credentials.email || account.email,
+                accountId: credentials.accountId || account.accountId,
+            }), nowIso());
+            const rechecked = await checkAccount(refreshed);
+            const recheckedAccount = markLastUsed(normalizeAccount({
+                ...rechecked.account,
+                lastCheck: rechecked.result,
+            }), nowIso());
+            nextStore = updateAccount(nextStore, recheckedAccount);
+            writeStore(paths, nextStore);
+            process.stdout.write(`✓ Re-logged '${recheckedAccount.email || recheckedAccount.label}'.\n`);
+        }
+        process.stdout.write(`\n${renderAccountsTable(nextStore)}\n`);
+        return;
+    }
+    if (opts.json) {
+        printJson({ accounts: nextStore.accounts });
+        return;
+    }
+    process.stdout.write(`${renderAccountsTable(nextStore)}\n`);
+});
+program
+    .command('delete')
+    .argument('<email>')
+    .description('remove an account by email')
+    .action((email) => {
+    const opts = program.opts();
+    const { paths, store } = getStore(opts);
+    const account = resolveAccountRef(store, email);
+    if (account.email !== email.trim()) {
+        throw new Error(`Account '${email}' not found by email.`);
+    }
+    const nextStore = removeAccountFromStore(store, account.id);
+    writeStore(paths, nextStore);
+    if (fs.existsSync(account.codexHome)) {
+        fs.rmSync(account.codexHome, { recursive: true, force: true });
+    }
+    if (opts.json) {
+        printJson({ removedAccountId: account.id, accounts: nextStore.accounts });
+        return;
+    }
+    process.stdout.write(`✓ Deleted '${account.email || account.label}'.\n`);
+});
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/dist/core/accounts.js

@@ -0,0 +1,197 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const STORE_VERSION = 1;
+export function createDataPaths(dataDir) {
+    return {
+        dataDir,
+        accountsFile: path.join(dataDir, 'accounts.json'),
+        codexHomesDir: path.join(dataDir, 'codex-homes'),
+    };
+}
+export function ensureDataPaths(paths) {
+    fs.mkdirSync(paths.dataDir, { recursive: true });
+    fs.mkdirSync(paths.codexHomesDir, { recursive: true });
+}
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function makeId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function numberOrNull(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function normalizeLastCheck(lastCheck) {
+    if (!lastCheck || typeof lastCheck !== 'object')
+        return null;
+    const input = lastCheck;
+    return {
+        ok: Boolean(input.ok),
+        planType: typeof input.planType === 'string' ? input.planType : null,
+        primaryUsedPercent: numberOrNull(input.primaryUsedPercent),
+        primaryRemainingPercent: numberOrNull(input.primaryRemainingPercent),
+        primaryResetAt: typeof input.primaryResetAt === 'string' ? input.primaryResetAt : null,
+        secondaryUsedPercent: numberOrNull(input.secondaryUsedPercent),
+        secondaryRemainingPercent: numberOrNull(input.secondaryRemainingPercent),
+        secondaryResetAt: typeof input.secondaryResetAt === 'string' ? input.secondaryResetAt : null,
+        creditsBalance: numberOrNull(input.creditsBalance),
+        creditsUnlimited: input.creditsUnlimited == null ? null : Boolean(input.creditsUnlimited),
+        sourceUsed: 'oauth',
+        checkedAt: typeof input.checkedAt === 'string' ? input.checkedAt : nowIso(),
+        elapsedMs: numberOrNull(input.elapsedMs) ?? 0,
+        error: typeof input.error === 'string' ? input.error : null,
+    };
+}
+export function normalizeAccount(account) {
+    return {
+        id: String(account.id),
+        label: account.label?.trim() || 'Codex Account',
+        email: account.email ?? null,
+        accountId: account.accountId ?? null,
+        codexHome: account.codexHome,
+        createdAt: account.createdAt || nowIso(),
+        lastUsedAt: account.lastUsedAt ?? null,
+        lastCheck: normalizeLastCheck(account.lastCheck),
+    };
+}
+function migrateStore(raw) {
+    if (Array.isArray(raw)) {
+        const accounts = raw
+            .filter((item) => Boolean(item) && typeof item === 'object')
+            .filter(item => typeof item.id === 'string' && typeof item.codexHome === 'string')
+            .map(item => normalizeAccount({
+            id: item.id,
+            label: typeof item.label === 'string' ? item.label : 'Codex Account',
+            email: typeof item.email === 'string' ? item.email : null,
+            accountId: typeof item.accountId === 'string' ? item.accountId : null,
+            codexHome: item.codexHome,
+            createdAt: typeof item.createdAt === 'string' ? item.createdAt : nowIso(),
+            lastUsedAt: typeof item.lastUsedAt === 'string' ? item.lastUsedAt : null,
+            lastCheck: item.lastCheck,
+        }));
+        return {
+            version: STORE_VERSION,
+            defaultAccountId: accounts[0]?.id ?? null,
+            accounts,
+        };
+    }
+    const input = raw && typeof raw === 'object' ? raw : {};
+    const accounts = Array.isArray(input.accounts)
+        ? input.accounts
+            .filter((item) => Boolean(item) && typeof item === 'object')
+            .filter(item => typeof item.id === 'string' && typeof item.codexHome === 'string')
+            .map(item => normalizeAccount({
+            id: item.id,
+            label: typeof item.label === 'string' ? item.label : 'Codex Account',
+            email: typeof item.email === 'string' ? item.email : null,
+            accountId: typeof item.accountId === 'string' ? item.accountId : null,
+            codexHome: item.codexHome,
+            createdAt: typeof item.createdAt === 'string' ? item.createdAt : nowIso(),
+            lastUsedAt: typeof item.lastUsedAt === 'string' ? item.lastUsedAt : null,
+            lastCheck: item.lastCheck,
+        }))
+        : [];
+    const defaultAccountId = typeof input.defaultAccountId === 'string' ? input.defaultAccountId : null;
+    return {
+        version: STORE_VERSION,
+        defaultAccountId: accounts.some(account => account.id === defaultAccountId)
+            ? defaultAccountId
+            : accounts[0]?.id ?? null,
+        accounts,
+    };
+}
+export function readStore(paths) {
+    ensureDataPaths(paths);
+    try {
+        const raw = JSON.parse(fs.readFileSync(paths.accountsFile, 'utf8'));
+        return migrateStore(raw);
+    }
+    catch {
+        return {
+            version: STORE_VERSION,
+            defaultAccountId: null,
+            accounts: [],
+        };
+    }
+}
+export function writeStore(paths, store) {
+    ensureDataPaths(paths);
+    const normalized = {
+        version: STORE_VERSION,
+        defaultAccountId: store.defaultAccountId,
+        accounts: store.accounts.map(account => normalizeAccount(account)),
+    };
+    fs.writeFileSync(paths.accountsFile, JSON.stringify(normalized, null, 2));
+}
+export function createCodexHome(paths, accountId) {
+    const codexHome = path.join(paths.codexHomesDir, accountId);
+    fs.mkdirSync(codexHome, { recursive: true });
+    const configPath = path.join(codexHome, 'config.toml');
+    if (!fs.existsSync(configPath)) {
+        fs.writeFileSync(configPath, '');
+    }
+    return codexHome;
+}
+export function updateAccount(store, nextAccount, options = {}) {
+    const existingIndex = store.accounts.findIndex(account => account.id === nextAccount.id);
+    const accounts = [...store.accounts];
+    if (existingIndex >= 0) {
+        accounts[existingIndex] = normalizeAccount(nextAccount);
+    }
+    else {
+        accounts.push(normalizeAccount(nextAccount));
+    }
+    const defaultAccountId = options.makeDefault
+        ? nextAccount.id
+        : (store.defaultAccountId ?? (accounts[0]?.id ?? null));
+    return {
+        version: STORE_VERSION,
+        defaultAccountId,
+        accounts,
+    };
+}
+export function markLastUsed(account, at = nowIso()) {
+    return {
+        ...account,
+        lastUsedAt: at,
+    };
+}
+export function resolveAccountRef(store, ref) {
+    const trimmed = ref.trim();
+    const byId = store.accounts.find(account => account.id === trimmed);
+    if (byId)
+        return byId;
+    const byEmail = store.accounts.filter(account => account.email === trimmed);
+    if (byEmail.length === 1)
+        return byEmail[0];
+    if (byEmail.length > 1) {
+        throw new Error(`Email '${trimmed}' matches multiple accounts. Use account id instead.`);
+    }
+    const matches = store.accounts.filter(account => account.label === trimmed);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1) {
+        throw new Error(`Label '${trimmed}' matches multiple accounts. Use account id instead.`);
+    }
+    throw new Error(`Account '${trimmed}' not found.`);
+}
+export function removeAccountFromStore(store, accountId) {
+    const accountExists = store.accounts.some(account => account.id === accountId);
+    if (!accountExists) {
+        throw new Error('Account not found');
+    }
+    const accounts = store.accounts.filter(account => account.id !== accountId);
+    let defaultAccountId = store.defaultAccountId;
+    if (defaultAccountId === accountId) {
+        const nextDefault = [...accounts].sort((a, b) => {
+            return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+        })[0];
+        defaultAccountId = nextDefault?.id ?? null;
+    }
+    return {
+        version: STORE_VERSION,
+        defaultAccountId,
+        accounts,
+    };
+}

package/dist/core/auth.js

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export const REFRESH_URL = 'https://auth.openai.com/oauth/token';
+export const OAUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+export const TOKEN_REFRESH_INTERVAL_MS = 8 * 24 * 60 * 60 * 1000;
+export function authFilePath(codexHome) {
+    return path.join(codexHome, 'auth.json');
+}
+function parseLastRefresh(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const parsed = new Date(raw);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function decodeJwtPayload(token) {
+    if (!token)
+        return null;
+    const parts = token.split('.');
+    if (parts.length < 2)
+        return null;
+    const normalized = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized + '='.repeat((4 - (normalized.length % 4 || 4)) % 4);
+    try {
+        return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveEmailFromTokens(tokens) {
+    const payload = decodeJwtPayload(asString(tokens.id_token)) || decodeJwtPayload(asString(tokens.access_token));
+    const profile = payload?.['https://api.openai.com/profile'];
+    const email = asString(payload?.email) || asString(profile?.email);
+    return email || null;
+}
+function resolvePlanFromTokens(tokens) {
+    const payload = decodeJwtPayload(asString(tokens.id_token)) || decodeJwtPayload(asString(tokens.access_token));
+    const auth = payload?.['https://api.openai.com/auth'];
+    return asString(auth?.chatgpt_plan_type) || asString(payload?.chatgpt_plan_type) || null;
+}
+function asString(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+export function ensureCodexInstalled() {
+    const result = spawnSync('codex', ['--version'], {
+        stdio: 'ignore',
+        env: process.env,
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error('codex CLI not found. Install it first and ensure it is on PATH.');
+    }
+}
+export function runCodexLogin(codexHome, verbose) {
+    ensureCodexInstalled();
+    const result = spawnSync('codex', ['login'], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            CODEX_HOME: codexHome,
+        },
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(`codex login failed with exit code ${result.status ?? 1}`);
+    }
+    if (verbose) {
+        process.stderr.write(`login completed for CODEX_HOME=${codexHome}\n`);
+    }
+}
+export function loadCredentials(codexHome) {
+    const file = authFilePath(codexHome);
+    if (!fs.existsSync(file)) {
+        throw new Error('auth.json not found. Run login first.');
+    }
+    const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const apiKey = asString(json.OPENAI_API_KEY);
+    if (apiKey) {
+        return {
+            authMode: 'api_key',
+            accessToken: apiKey,
+            refreshToken: '',
+            idToken: null,
+            accountId: null,
+            email: null,
+            planType: null,
+            lastRefresh: null,
+        };
+    }
+    const tokens = (json.tokens && typeof json.tokens === 'object') ? json.tokens : {};
+    const accessToken = asString(tokens.access_token);
+    if (!accessToken) {
+        throw new Error('auth.json exists but tokens are missing');
+    }
+    return {
+        authMode: asString(json.auth_mode) || 'chatgpt',
+        accessToken,
+        refreshToken: asString(tokens.refresh_token) || '',
+        idToken: asString(tokens.id_token),
+        accountId: asString(tokens.account_id),
+        email: resolveEmailFromTokens(tokens),
+        planType: resolvePlanFromTokens(tokens),
+        lastRefresh: parseLastRefresh(json.last_refresh),
+    };
+}
+export function saveCredentials(codexHome, credentials) {
+    const file = authFilePath(codexHome);
+    let json = {};
+    if (fs.existsSync(file)) {
+        try {
+            json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch {
+            json = {};
+        }
+    }
+    json.auth_mode = credentials.authMode;
+    json.tokens = {
+        ...(json.tokens && typeof json.tokens === 'object' ? json.tokens : {}),
+        access_token: credentials.accessToken,
+        refresh_token: credentials.refreshToken,
+        id_token: credentials.idToken,
+        account_id: credentials.accountId,
+    };
+    json.last_refresh = new Date().toISOString();
+    fs.writeFileSync(file, JSON.stringify(json, null, 2));
+}
+export async function refreshCredentialsIfNeeded(codexHome, credentials) {
+    if (!credentials.refreshToken)
+        return credentials;
+    if (credentials.lastRefresh && Date.now() - credentials.lastRefresh.getTime() < TOKEN_REFRESH_INTERVAL_MS) {
+        return credentials;
+    }
+    const refreshed = await refreshCredentials(credentials);
+    saveCredentials(codexHome, refreshed);
+    return refreshed;
+}
+export async function refreshCredentials(credentials) {
+    const response = await fetch(REFRESH_URL, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            client_id: OAUTH_CLIENT_ID,
+            grant_type: 'refresh_token',
+            refresh_token: credentials.refreshToken,
+            scope: 'openid profile email',
+        }),
+    });
+    if (response.status === 401) {
+        throw new Error('Refresh token expired or revoked. Run relogin.');
+    }
+    if (!response.ok) {
+        throw new Error(`Token refresh failed with HTTP ${response.status}`);
+    }
+    const json = await response.json();
+    return {
+        ...credentials,
+        accessToken: asString(json.access_token) || credentials.accessToken,
+        refreshToken: asString(json.refresh_token) || credentials.refreshToken,
+        idToken: asString(json.id_token) || credentials.idToken,
+        lastRefresh: new Date(),
+    };
+}

package/dist/core/output.js

@@ -0,0 +1,182 @@
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+const WHITE = '\x1b[37m';
+const BG_GREEN = '\x1b[42m';
+const BG_YELLOW = '\x1b[43m';
+const BG_RED = '\x1b[41m';
+const BG_GRAY = '\x1b[100m';
+function colorEnabled() {
+    return process.stdout.isTTY !== false && !process.env.NO_COLOR;
+}
+function c(color, text) {
+    return colorEnabled() ? `${color}${text}${RESET}` : text;
+}
+function formatDate(value) {
+    if (!value)
+        return '-';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return value;
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    const diffMin = Math.floor(diffMs / 60_000);
+    if (diffMin < 1)
+        return 'just now';
+    if (diffMin < 60)
+        return `${diffMin}m ago`;
+    const diffHr = Math.floor(diffMin / 60);
+    if (diffHr < 24)
+        return `${diffHr}h ago`;
+    const diffDay = Math.floor(diffHr / 24);
+    return `${diffDay}d ago`;
+}
+function progressBar(remainingPercent, width = 12) {
+    const clamped = Math.max(0, Math.min(100, remainingPercent));
+    const filled = Math.round((clamped / 100) * width);
+    const empty = width - filled;
+    let barColor;
+    if (clamped <= 20)
+        barColor = BG_RED;
+    else if (clamped <= 50)
+        barColor = BG_YELLOW;
+    else
+        barColor = BG_GREEN;
+    if (!colorEnabled()) {
+        return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
+    }
+    return `${barColor}${' '.repeat(filled)}${RESET}${BG_GRAY}${' '.repeat(empty)}${RESET}`;
+}
+function formatUsage(usedPercent, remainingPercent, resetAt) {
+    if (usedPercent == null && remainingPercent == null)
+        return c(DIM, '-');
+    const remaining = remainingPercent ?? (100 - (usedPercent ?? 0));
+    const bar = progressBar(remaining);
+    const pctText = `${remaining}%`;
+    let coloredPct;
+    if (remaining <= 20)
+        coloredPct = c(RED + BOLD, pctText);
+    else if (remaining <= 50)
+        coloredPct = c(YELLOW, pctText);
+    else
+        coloredPct = c(GREEN, pctText);
+    let resetText = '';
+    if (resetAt) {
+        const resetDate = new Date(resetAt);
+        if (!Number.isNaN(resetDate.getTime())) {
+            const diffMs = resetDate.getTime() - Date.now();
+            if (diffMs > 0) {
+                const totalMin = Math.floor(diffMs / 60_000);
+                const days = Math.floor(totalMin / 1440);
+                const hours = Math.floor((totalMin % 1440) / 60);
+                const mins = totalMin % 60;
+                const parts = [];
+                if (days > 0)
+                    parts.push(`${days}d`);
+                if (hours > 0)
+                    parts.push(`${hours}h`);
+                parts.push(`${mins}m`);
+                resetText = c(DIM, ` ↻${parts.join('')}`);
+            }
+        }
+    }
+    return `${bar} ${coloredPct}${resetText}`;
+}
+function formatCredits(lastCheck) {
+    if (!lastCheck)
+        return c(DIM, '-');
+    if (lastCheck.creditsUnlimited)
+        return c(GREEN + BOLD, '∞');
+    if (lastCheck.creditsBalance == null)
+        return c(DIM, '-');
+    const balance = lastCheck.creditsBalance;
+    if (balance <= 0)
+        return c(RED, '$' + balance.toFixed(2));
+    return c(GREEN, '$' + balance.toFixed(2));
+}
+function formatPlan(plan) {
+    if (!plan)
+        return c(DIM, '-');
+    const upper = plan.charAt(0).toUpperCase() + plan.slice(1);
+    if (plan === 'plus')
+        return c(CYAN + BOLD, upper);
+    if (plan === 'team')
+        return c(GREEN + BOLD, upper);
+    if (plan === 'pro')
+        return c(YELLOW + BOLD, upper);
+    return c(WHITE + BOLD, upper);
+}
+function formatStatus(lastCheck) {
+    if (!lastCheck)
+        return c(DIM, 'Not checked');
+    if (lastCheck.ok)
+        return c(GREEN + BOLD, '● OK');
+    return c(RED + BOLD, '✗ ') + c(RED, (lastCheck.error || 'Unknown').slice(0, 30));
+}
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function visibleLength(str) {
+    return stripAnsi(str).length;
+}
+function padVisible(value, width) {
+    const vLen = visibleLength(value);
+    if (vLen >= width)
+        return value;
+    return value + ' '.repeat(width - vLen);
+}
+const BOX_TOP_LEFT = '┌';
+const BOX_TOP_RIGHT = '┐';
+const BOX_BOTTOM_LEFT = '└';
+const BOX_BOTTOM_RIGHT = '┘';
+const BOX_H = '─';
+const BOX_V = '│';
+const BOX_T_DOWN = '┬';
+const BOX_T_UP = '┴';
+const BOX_T_RIGHT = '├';
+const BOX_T_LEFT = '┤';
+const BOX_CROSS = '┼';
+function renderTable(headers, rows) {
+    const colWidths = headers.map((header, i) => {
+        const headerLen = visibleLength(header);
+        const maxRowLen = rows.reduce((max, row) => Math.max(max, visibleLength(row[i] ?? '')), 0);
+        return Math.max(headerLen, maxRowLen) + 2;
+    });
+    const hLine = (left, mid, right) => left + colWidths.map(w => BOX_H.repeat(w)).join(mid) + right;
+    const dataLine = (parts) => BOX_V + parts.map((part, i) => ' ' + padVisible(part, colWidths[i] - 1)).join(BOX_V) + BOX_V;
+    const lines = [];
+    lines.push(c(DIM, hLine(BOX_TOP_LEFT, BOX_T_DOWN, BOX_TOP_RIGHT)));
+    lines.push(c(DIM, BOX_V) + headers.map((h, i) => ' ' + c(BOLD, padVisible(h, colWidths[i] - 1))).join(c(DIM, BOX_V)) + c(DIM, BOX_V));
+    lines.push(c(DIM, hLine(BOX_T_RIGHT, BOX_CROSS, BOX_T_LEFT)));
+    for (const row of rows) {
+        lines.push(c(DIM, BOX_V) + row.map((cell, i) => ' ' + padVisible(cell, colWidths[i] - 1)).join(c(DIM, BOX_V)) + c(DIM, BOX_V));
+    }
+    lines.push(c(DIM, hLine(BOX_BOTTOM_LEFT, BOX_T_UP, BOX_BOTTOM_RIGHT)));
+    return lines.join('\n');
+}
+export function renderAccountsTable(store) {
+    if (store.accounts.length === 0) {
+        return c(DIM, 'No accounts configured. Run `add` to get started.');
+    }
+    const rows = store.accounts.map(account => {
+        const isDefault = store.defaultAccountId === account.id;
+        const marker = isDefault ? c(GREEN + BOLD, '→') : ' ';
+        return [
+            marker,
+            c(isDefault ? WHITE + BOLD : WHITE, account.email || '-'),
+            formatUsage(account.lastCheck?.primaryUsedPercent ?? null, account.lastCheck?.primaryRemainingPercent ?? null, account.lastCheck?.primaryResetAt ?? null),
+            formatUsage(account.lastCheck?.secondaryUsedPercent ?? null, account.lastCheck?.secondaryRemainingPercent ?? null, account.lastCheck?.secondaryResetAt ?? null),
+            formatCredits(account.lastCheck),
+            formatStatus(account.lastCheck),
+        ];
+    });
+    const title = c(BOLD, `Accounts (${store.accounts.length})`);
+    return `${title}\n${renderTable(['', 'Email', '5h Remaining', 'Weekly Remaining', 'Credits', 'Status'], rows)}`;
+}
+export function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}

package/dist/core/usage.js

@@ -0,0 +1,101 @@
+import { loadCredentials, refreshCredentialsIfNeeded } from './auth.js';
+const DEFAULT_USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
+const FALLBACK_USAGE_URL = 'https://chatgpt.com/api/codex/usage';
+function numberOrNull(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Math.round(value)));
+}
+function usageHeaders(credentials) {
+    const headers = {
+        Authorization: `Bearer ${credentials.accessToken}`,
+        Accept: 'application/json',
+        'User-Agent': 'codex-cli',
+    };
+    if (credentials.accountId) {
+        headers['ChatGPT-Account-Id'] = credentials.accountId;
+    }
+    return headers;
+}
+async function fetchUsage(credentials) {
+    const startedAt = Date.now();
+    let response = await fetch(DEFAULT_USAGE_URL, { headers: usageHeaders(credentials) });
+    if (response.status === 404) {
+        response = await fetch(FALLBACK_USAGE_URL, { headers: usageHeaders(credentials) });
+    }
+    if (response.status === 401 || response.status === 403) {
+        throw new Error('Unauthorized. Run relogin.');
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Usage API failed with HTTP ${response.status}: ${text.slice(0, 200)}`);
+    }
+    return {
+        payload: await response.json(),
+        elapsedMs: Date.now() - startedAt,
+    };
+}
+function normalizeSuccess(account, credentials, usage) {
+    const primary = usage.payload.rate_limit?.primary_window;
+    const secondary = usage.payload.rate_limit?.secondary_window;
+    const credits = usage.payload.credits;
+    const primaryUsed = numberOrNull(primary?.used_percent);
+    const secondaryUsed = numberOrNull(secondary?.used_percent);
+    return {
+        ok: true,
+        planType: usage.payload.plan_type || credentials.planType || null,
+        primaryUsedPercent: primaryUsed,
+        primaryRemainingPercent: primaryUsed == null ? null : clampPercent(100 - primaryUsed),
+        primaryResetAt: primary?.reset_at ? new Date(primary.reset_at * 1000).toISOString() : null,
+        secondaryUsedPercent: secondaryUsed,
+        secondaryRemainingPercent: secondaryUsed == null ? null : clampPercent(100 - secondaryUsed),
+        secondaryResetAt: secondary?.reset_at ? new Date(secondary.reset_at * 1000).toISOString() : null,
+        creditsBalance: numberOrNull(credits?.balance),
+        creditsUnlimited: credits?.unlimited == null ? null : Boolean(credits.unlimited),
+        sourceUsed: 'oauth',
+        checkedAt: new Date().toISOString(),
+        elapsedMs: usage.elapsedMs,
+        error: null,
+    };
+}
+function normalizeFailure(error) {
+    return {
+        ok: false,
+        planType: null,
+        primaryUsedPercent: null,
+        primaryRemainingPercent: null,
+        primaryResetAt: null,
+        secondaryUsedPercent: null,
+        secondaryRemainingPercent: null,
+        secondaryResetAt: null,
+        creditsBalance: null,
+        creditsUnlimited: null,
+        sourceUsed: 'oauth',
+        checkedAt: new Date().toISOString(),
+        elapsedMs: 0,
+        error: error.message,
+    };
+}
+export async function checkAccount(account) {
+    try {
+        let credentials = loadCredentials(account.codexHome);
+        credentials = await refreshCredentialsIfNeeded(account.codexHome, credentials);
+        const usage = await fetchUsage(credentials);
+        return {
+            account: {
+                ...account,
+                email: credentials.email || account.email,
+                accountId: credentials.accountId || account.accountId,
+            },
+            result: normalizeSuccess(account, credentials, usage),
+        };
+    }
+    catch (error) {
+        return {
+            account,
+            result: normalizeFailure(error),
+        };
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kodo/agent-meter",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "CLI tool for managing multiple Codex OAuth accounts and checking rate limits",
+  "bin": {
+    "agent-meter": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "codex",
+    "openai",
+    "usage",
+    "rate-limit",
+    "cli"
+  ],
+  "author": "MeCKodo <kodoo@foxmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MeCKodo/agent-meter.git"
+  },
+  "dependencies": {
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}