@guenbankhai/tools 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# @guenbankhai/tools
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Tiếng Việt](README.vi.md)
+
+Small local command-line tools for Windows, one folder per tool. Requires Node.js 20+. The package is public on npmjs.com as `@guenbankhai/tools`.
+
+## Tools
+
+| Command | Purpose | Docs |
+| --- | --- | --- |
+| `agentmoni` | Watch live Claude Code and Codex sessions, their parent-child links and quota use | [agentmoni README](agentmoni/README.md) |
+
+One package, one version: installing `@guenbankhai/tools` installs every tool.
+
+## Install
+
+Installing needs no account or token.
+
+### Install
+
+```
+npm i -g @guenbankhai/tools
+npm i -g @guenbankhai/tools@0.1.0  # pin a version
+```
+
+### Update
+
+```
+npm i -g @guenbankhai/tools@latest
+npm update -g
+```
+
+### Uninstall
+
+```
+npm rm -g @guenbankhai/tools
+```
+
+### Check
+
+```
+npm ls -g --depth=0
+Get-Command agentmoni -All
+```
+
+## Development
+
+Clone the repo, run `npm test` at the root to run the tests of every tool.
+
+## Releases
+
+See [CHANGELOG](CHANGELOG.md).
+
+For the repo owner: tag `vX.Y.Z` on `master` and create a GitHub Release, then log in with `npm login` (npmjs.com) and run `npm publish` at the root.

package/README.vi.md

@@ -0,0 +1,54 @@
+# @guenbankhai/tools
+
+[English](README.md)
+
+Các công cụ dòng lệnh cục bộ nhỏ cho Windows, mỗi công cụ một thư mục. Cần Node.js 20+. Gói công khai trên npmjs.com với tên `@guenbankhai/tools`.
+
+## Công cụ
+
+| Lệnh | Mục đích | Tài liệu |
+| --- | --- | --- |
+| `agentmoni` | Theo dõi các session Claude Code và Codex đang chạy, quan hệ cha-con giữa chúng và mức dùng quota | [agentmoni README](agentmoni/README.vi.md) |
+
+Một gói, một version: cài `@guenbankhai/tools` là cài mọi công cụ.
+
+## Cài đặt
+
+Cài đặt không cần tài khoản hay token.
+
+### Cài
+
+```
+npm i -g @guenbankhai/tools
+npm i -g @guenbankhai/tools@0.1.0  # ghim version
+```
+
+### Cập nhật
+
+```
+npm i -g @guenbankhai/tools@latest
+npm update -g
+```
+
+### Gỡ cài đặt
+
+```
+npm rm -g @guenbankhai/tools
+```
+
+### Kiểm tra
+
+```
+npm ls -g --depth=0
+Get-Command agentmoni -All
+```
+
+## Phát triển
+
+Clone repo, chạy `npm test` ở thư mục gốc để chạy test của mọi công cụ.
+
+## Phát hành
+
+Xem [CHANGELOG](CHANGELOG.vi.md).
+
+Dành cho người giữ repo: tạo tag `vX.Y.Z` trên `master` và một GitHub Release, rồi đăng nhập bằng `npm login` (npmjs.com) và chạy `npm publish` ở thư mục gốc.

package/agentmoni/lib/agents/claude/billing.js

@@ -0,0 +1,13 @@
+const os = require('node:os');
+const path = require('node:path');
+const { readFields } = require('../../json-fields.js');
+function readBilling({ home = os.homedir(), env = process.env, claudeHome = env.CLAUDE_CONFIG_DIR ?? path.join(home, '.claude') } = {}) {
+  if (Object.hasOwn(env, 'ANTHROPIC_API_KEY') || env.CLAUDE_CODE_USE_BEDROCK === '1' || env.CLAUDE_CODE_USE_VERTEX === '1') return 'api';
+  const settings = readFields(path.join(claudeHome, 'settings.json'), ['apiKeyHelper'], ['apiKeyHelper']);
+  if (settings.apiKeyHelper) return 'api';
+  const credentials = readFields(path.join(claudeHome, '.credentials.json'), ['claudeAiOauth.subscriptionType']);
+  if (['pro', 'max', 'team', 'enterprise'].includes(credentials['claudeAiOauth.subscriptionType'])) return 'subscription';
+  const config = readFields(path.join(home, '.claude.json'), ['oauthAccount.billingType']);
+  return ['stripe_subscription', 'subscription'].includes(config['oauthAccount.billingType']) ? 'subscription' : 'unknown';
+}
+module.exports = { readBilling };

package/agentmoni/lib/agents/claude/home.js

@@ -0,0 +1,4 @@
+const os = require('node:os');
+const path = require('node:path');
+const claudeDir = () => process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.claude');
+module.exports = { claudeDir };

package/agentmoni/lib/agents/claude/index.js

@@ -0,0 +1,181 @@
+// Claude adapter: transcripts under ~/.claude/projects/<dir>/<session>.jsonl and <session>/subagents/agent-*.jsonl.
+const fs = require('node:fs');
+const path = require('node:path');
+const { files, scan, cached } = require('../../jsonl.js');
+const { launchKind, launchOf, launchCwd, resultJob, resultSessions } = require('../../launch.js');
+
+const { readBilling } = require('./billing.js');
+const declaration = require('../../catalog.json').agents.claude;
+const { claudeDir } = require('./home.js');
+const WANT = ['"type":"user"', '"type":"assistant"', '"subtype":"turn_duration"', '"type":"api-request"', '"type":"ai-title"', '"type":"custom-title"'];
+const titleText = v => typeof v === 'string' && v.trim() ? v.replace(/\s+/g, ' ').trim().slice(0, 120) : null;
+const num = v => v ?? 0;
+const validUsage = u => u && typeof u === 'object' &&
+  ['input_tokens', 'output_tokens'].every(k => Number.isSafeInteger(u[k]) && u[k] >= 0) &&
+  ['cache_read_input_tokens', 'cache_creation_input_tokens'].every(k => u[k] === undefined || (Number.isSafeInteger(u[k]) && u[k] >= 0)) &&
+  (u.cache_creation === undefined || (u.cache_creation &&
+    ['ephemeral_5m_input_tokens', 'ephemeral_1h_input_tokens'].every(k => Number.isSafeInteger(u.cache_creation[k]) && u.cache_creation[k] >= 0)));
+
+function promptText(message) {
+  const c = message?.content;
+  const text = typeof c === 'string' ? c : Array.isArray(c) ? c.find(i => i?.type === 'text')?.text : null;
+  // A leading "<" marks injected system text (command caveats, reminders), not what the user typed.
+  if (typeof text !== 'string' || text.trimStart().startsWith('<')) return null;
+  return text.replace(/\s+/g, ' ').trim().slice(0, 80) || null;
+}
+
+// Parses one transcript. Returns null when the file holds no usable record.
+function parseTranscript(file) {
+  const sub = path.basename(path.dirname(file)) === 'subagents';
+  const s = { provider: 'claude', id: path.basename(file, '.jsonl'), parentId: null, model: null, effort: null, cwd: null, name: null,
+    startedAt: null, lastActivityAt: null, kind: sub ? 'sub' : 'main', tokens: null, context: null, turn: null, launches: [], usage: [], source: { file } };
+  if (sub) s.parentId = path.basename(path.dirname(path.dirname(file)));
+  const calls = new Map();
+  const messages = new Map();   // message.id -> { u, at, model }; streaming repeats a message, the last copy is complete
+  let lastUsage = null, entrypoint = null, aiTitle = null, customTitle = null;   // the title lines repeat; the last one is current
+  s.bad = scan(file, line => WANT.some(w => line.includes(w)), r => {
+    if (r.type === 'ai-title') { aiTitle = titleText(r.aiTitle) ?? aiTitle; return; }
+    if (r.type === 'custom-title') { customTitle = titleText(r.customTitle) ?? customTitle; return; }
+    const at = Date.parse(r.timestamp);
+    if (Number.isFinite(at)) { s.startedAt ??= at; s.lastActivityAt = at; }
+    s.cwd ??= typeof r.cwd === 'string' ? r.cwd : null;
+    if (r.type === 'api-request') {
+      const effort = /"effort":"(\w+)"/.exec(JSON.stringify(r.params ?? {}))?.[1];
+      if (effort) s.effort = effort;
+    } else if (r.type === 'user' && !r.isMeta) {
+      for (const c of Array.isArray(r.message?.content) ? r.message.content : []) {
+        const l = c?.type === 'tool_result' && calls.get(c.tool_use_id);
+        if (l) { l.job = resultJob(c.content); if (l.kind === 'claude -p') l.sessionIds = resultSessions(c.content); }
+      }
+      entrypoint ??= r.entrypoint ?? null;
+      s.prompt ??= promptText(r.message);
+      s.turn = r.toolEndsTurn ? 'done' : 'open';   // a prompt or a tool result; toolEndsTurn is the final tool of a sub-agent (SubagentHandback)
+    } else if (r.type === 'assistant' && r.message) {
+      const m = r.message;
+      if (m.model && m.model !== '<synthetic>') s.model = m.model;
+      if (m.model !== '<synthetic>') { messages.set(m.id ?? r.uuid ?? messages.size, { u: m.usage, at, model: m.model ?? null, costUSD: m.costUSD ?? r.costUSD, speed: m.speed ?? m.usage?.speed ?? r.speed, inference_geo: m.inference_geo ?? m.usage?.inference_geo ?? r.inference_geo }); lastUsage = m.usage; }
+      for (const c of Array.isArray(m.content) ? m.content : []) {
+        const kind = c?.type === 'tool_use' ? launchKind(c.input?.command) : null;
+        if (kind) {
+          const l = launchOf(at, kind, c.input.command);
+          l.cwd = launchCwd(c.input.command, c.input.cwd ?? r.cwd ?? s.cwd, kind === 'codex plugin' ? ['--cwd'] : ['-C', '--cd']);
+          l.toolUseId = c.id;
+          s.launches.push(l);
+          if (typeof c.id === 'string') calls.set(c.id, l);
+        }
+      }
+      s.turn = m.stop_reason === 'end_turn' ? 'done' : 'open';
+    } else if (r.type === 'system') s.turn = 'done';
+  });
+  if (s.startedAt == null) return null;
+  s.name = customTitle ?? aiTitle ?? s.prompt;   // a sub-agent's description (below) replaces it
+  const t = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, cacheWrite1h: 0 };
+  for (const { u, at, model, costUSD, speed, inference_geo } of messages.values()) {
+    if (!validUsage(u)) continue;
+    const e = { at, model, cacheWrite1h: u.cache_creation?.ephemeral_1h_input_tokens ?? 0, input: num(u.input_tokens), cacheRead: num(u.cache_read_input_tokens), cacheWrite: num(u.cache_creation_input_tokens), output: num(u.output_tokens) };
+    for (const k of ['input', 'cacheRead', 'cacheWrite', 'output', 'cacheWrite1h']) t[k] += e[k];
+    if (Number.isFinite(at)) s.usage.push({ at, model, speed, inference_geo, tokens: Object.fromEntries(Object.entries(e).filter(([k]) => k !== 'at' && k !== 'model')), ...(Number.isFinite(costUSD) && costUSD >= 0 ? { costUSD } : {}) });
+  }
+  s.tokens = t;
+  if (validUsage(lastUsage)) s.context = num(lastUsage.input_tokens) + num(lastUsage.cache_read_input_tokens) + num(lastUsage.cache_creation_input_tokens);
+  if (sub) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(file.replace(/\.jsonl$/, '.meta.json'), 'utf8'));
+      s.agentType = typeof meta.agentType === 'string' ? meta.agentType : null;
+      if (typeof meta.description === 'string' && meta.description.trim()) s.name = meta.description.replace(/\s+/g, ' ').trim().slice(0, 80);
+    } catch { s.agentType = null; }
+  } else if (entrypoint === 'sdk-cli') s.kind = 'standalone';   // claude -p: a parent, if any, is resolved by the link step
+  s.entrypoint = entrypoint;
+  return s;
+}
+
+// shortcut: a changed transcript is re-read whole (unchanged ones come from the cache); upgrade to offset reads if one gets huge.
+function readSessions({ claudeHome = claudeDir(), dir = path.join(claudeHome, 'projects'), since = 0, ...options } = {}) {
+  const billing = readBilling({ ...options, claudeHome });
+  return files(dir, since).map(f => cached(f, parseTranscript)).filter(Boolean).map(s => ({ ...s, billing }));
+}
+
+const STALE_MS = 15 * 60 * 1000;   // only for a Claude sub-agent whose parent session is not on disk to ask
+const PID_START_SLACK_MS = 5000;   // pid file procStart vs. the process table (guards against pid reuse)
+
+const isClaude = p => p.name === 'claude.exe' || p.name === 'claude';
+const isHeadlessClaude = p => isClaude(p) && /\s(-p|--print)(\s|$)/.test(p.cmd);
+
+function claudeAlive(entry, procs) {
+  const p = procs.find(x => x.pid === entry.pid && isClaude(x));
+  if (!p) return null;
+  return entry.procStartMs == null || Math.abs(p.startMs - entry.procStartMs) <= PID_START_SLACK_MS ? p : null;
+}
+
+function liveness({ sessions, procs, pidFiles, now, owners = new Map(), claim }) {
+  const out = new Map(), claimed = new Set(), key = s => `${s.provider}:${s.id}`;
+  const set = (s, state, pid = null) => out.set(key(s), { state, pid });
+  const order = [...sessions].sort((a, b) => b.startedAt - a.startedAt);
+  for (const s of order.filter(x => x.provider === 'claude' && x.kind !== 'sub')) {
+    const entry = pidFiles.find(e => e.sessionId === s.id && claudeAlive(e, procs));
+    if (entry) { set(s, entry.status === 'busy' ? 'running' : 'waiting', entry.pid); claimed.add(entry.pid); continue; }
+    // claude -p writes no pid file here (seen on this machine only for interactive runs): match by start time.
+    const p = s.kind === 'standalone' ? claim(procs.filter(isHeadlessClaude), s, claimed, owners) : null;
+    set(s, p ? (s.turn === 'open' ? 'running' : 'waiting') : 'ended', p?.pid ?? null);
+  }
+
+  for (const s of sessions.filter(x => x.provider === 'claude' && x.kind === 'sub')) {
+    const parent = out.get(`claude:${s.parentId}`);
+    // Known parent: alive while the parent is and the result has not come back. Unknown parent: recency is all there is.
+    const alive = s.turn !== 'done' && (parent ? parent.state !== 'ended' : now - s.lastActivityAt < STALE_MS);
+    set(s, alive ? 'running' : 'ended');
+  }
+  return out;
+}
+
+const FILETIME_EPOCH_MS = 11644473600000;   // 1601-01-01 to 1970-01-01
+const filetimeToMs = ft => Number(BigInt(ft) / 10000n) - FILETIME_EPOCH_MS;
+
+// Live Claude sessions register ~/.claude/sessions/<pid>.json; other files in the folder (.key etc.) are ignored.
+function readClaudePidFiles(dir = path.join(claudeDir(), 'sessions')) {
+  let names;
+  try { names = fs.readdirSync(dir); } catch { return []; }
+  const out = [];
+  for (const name of names) {
+    if (!/^\d+\.json$/.test(name)) continue;
+    try {
+      const j = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));
+      if (j?.pid !== Number.parseInt(name, 10) || typeof j.sessionId !== 'string') continue;
+      let procStartMs = null;
+      try { procStartMs = filetimeToMs(j.procStart); } catch { /* no start time: pid alone decides */ }
+      out.push({ pid: j.pid, sessionId: j.sessionId, cwd: j.cwd ?? null, status: j.status ?? null, kind: j.kind ?? null, procStartMs });
+    } catch { /* partial or unreadable file */ }
+  }
+  return out;
+}
+
+const { createClaudeQuota } = require('./sources/oauth-usage.js');
+const readJson = file => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+
+function loadLimits({ claudeHome = claudeDir() } = {}) {
+  const table = new Map();
+  const dir = path.join(claudeHome, 'cache', 'model-catalog');
+  let files = []; try { files = fs.readdirSync(dir).filter(f => f.endsWith('.json')); } catch { /* no cache yet */ }
+  for (const f of files) {
+    const models = readJson(path.join(dir, f))?.catalog?.config?.models;
+    for (const m of Array.isArray(models) ? models : [])
+      if (typeof m?.id === 'string' && Number.isSafeInteger(m?.runtime?.max_input_tokens) && m.runtime.max_input_tokens > 0) table.set(m.id, m.runtime.max_input_tokens);
+  }
+  return table;
+}
+
+const launchPatterns = [
+  ['claude -p', /^["']?\S*\bclaude(?:\.exe|\.cmd)?["']?\s+(?:\S+\s+)*?(?:-p|--print)(?:\s|$)/]
+];
+
+module.exports = { readTimeline: require('./timeline.js').readTimeline,
+  readSessions, claudeDir, readClaudePidFiles, filetimeToMs, createClaudeQuota,
+  readBilling,
+  processNames: ['claude.exe', 'claude'], liveness, loadLimits, launchPatterns,
+  launchLine: line => line.includes('"type":"tool_use"'),
+  launchCalls: r => Array.isArray(r.message?.content) ? r.message.content.filter(c => c?.type === 'tool_use').map(c => [c.id, [c.input?.command]]) : [],
+  launchClaims: l => l.kind === 'claude -p' ? (l.sessionIds ?? []).map(id => 'claude:' + id) : [],
+  readPidFiles: readClaudePidFiles,
+  parentLabel: 'Agent tool', launchKindOf: s => s.parentId ? null : s.entrypoint === 'sdk-cli' ? 'claude -p' : null,
+  launchPolicy: () => ({ process: true })
+};

package/agentmoni/lib/agents/claude/sources/oauth-usage.js

@@ -0,0 +1,74 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { claudeDir } = require('../home.js');
+const declaration = require('../../../catalog.json').agents.claude;
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const REFRESH_MS = 3 * 60 * 1000;
+const RETRY_LIMITED_MS = 10 * 60 * 1000;
+const CLAUDE_KEYS = Object.fromEntries(declaration.windows.map(w => [w.id, w.field]));
+const readJson = file => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+function writeJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, JSON.stringify(data)); fs.renameSync(temp, file);
+}
+const validPercent = v => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+const afterReset = (resetsAt, now) => resetsAt != null && resetsAt <= now;
+
+// A window missing from a newer reply (seen when a limit is hit) must not erase a reading that has not reset yet.
+function mergeWindows(previous, body, at) {
+  const result = {};
+  for (const w of Object.keys(CLAUDE_KEYS)) {
+    const next = body?.[CLAUDE_KEYS[w]], old = previous?.[w];
+    if (validPercent(next?.utilization)) result[w] = { percent: next.utilization, resetsAt: Date.parse(next.resets_at) || null, at };
+    else if (old && old.resetsAt > at) result[w] = old;
+  }
+  return result;
+}
+
+// The cache file is shared, so several monitors make at most one request per interval.
+function createClaudeQuota({ claudeDir, cacheFile, fetch = globalThis.fetch }) {
+  let pending = null;
+  function token(at) {
+    const oauth = readJson(path.join(claudeDir, '.credentials.json'))?.claudeAiOauth;
+    if (typeof oauth?.accessToken !== 'string') throw new Error('Claude login not found (OAuth credentials are required)');
+    // shortcut: an expired token is not refreshed here; Claude Code refreshes it on its next request.
+    if (Number.isFinite(oauth.expiresAt) && oauth.expiresAt <= at) throw new Error('Claude token expired; it refreshes when Claude Code next runs');
+    return oauth.accessToken;
+  }
+  async function fetchUsage(at, cache) {
+    try {
+      const response = await fetch(USAGE_URL, { headers: { Authorization: `Bearer ${token(at)}`, 'anthropic-beta': 'oauth-2025-04-20' }, signal: AbortSignal.timeout(10000) });
+      if (!response.ok) {
+        const wait = response.status === 429 ? RETRY_LIMITED_MS : REFRESH_MS;
+        throw Object.assign(new Error(response.status === 429 ? 'usage endpoint rate-limited' : `usage endpoint returned HTTP ${response.status}`), { wait });
+      }
+      writeJson(cacheFile, { windows: mergeWindows(cache?.windows, await response.json(), at), checkedAt: at, nextAt: at + REFRESH_MS, error: null });
+    } catch (error) {
+      writeJson(cacheFile, { windows: mergeWindows(cache?.windows, null, at), checkedAt: at, nextAt: at + (error.wait ?? REFRESH_MS), error: error.message });
+    }
+  }
+  return {
+    // Asks the endpoint unless the cache is younger than 3 minutes.
+    refresh(at = Date.now()) {
+      const cache = readJson(cacheFile);
+      if (pending || (Number.isFinite(cache?.nextAt) && at < cache.nextAt && at >= cache.checkedAt)) return pending ?? Promise.resolve();
+      pending = fetchUsage(at, cache).catch(() => {}).finally(() => { pending = null; });
+      return pending;
+    },
+    read(now = Date.now()) {
+      const cache = readJson(cacheFile);
+      const windows = [];
+      for (const w of Object.keys(CLAUDE_KEYS)) {
+        const r = cache?.windows?.[w];
+        windows.push({ id: w, label: declaration.windows.find(x => x.id === w).label, usedPercent: r && !afterReset(r.resetsAt, now) ? r.percent : null, reset: !!r && afterReset(r.resetsAt, now), resetsAt: r?.resetsAt ?? null, readAt: r?.at ?? cache?.checkedAt ?? null });
+      }
+      return { windows, readAt: cache?.checkedAt ?? null, source: 'live', error: cache?.error ?? (cache ? null : 'no reading yet') };
+    }
+  };
+}
+
+module.exports = { createClaudeQuota, createQuota: ({ claudeHome = claudeDir(), logDir, fetch }) => {
+  const q = createClaudeQuota({ claudeDir: claudeHome, cacheFile: path.join(logDir, '_machine', 'claude-usage.json'), fetch });
+  return { refresh: q.refresh, read: (sessions, now) => q.read(now) };
+} };

package/agentmoni/lib/agents/claude/timeline.js

@@ -0,0 +1,26 @@
+const { read, clip, typed, toolText, n } = require('../../timeline.js');
+function readTimeline(file) {
+  return read(file, (r, { out, add, lastOf, seen }) => {
+    const m = r.message;
+    if (r.type === 'user' && m) {
+      const c = m.content, t = typeof c === 'string' ? c : Array.isArray(c) ? c.find(i => i?.type === 'text')?.text : null;
+      if (!r.isMeta && typed(t)) add(r, 'user', clip(t));
+    } else if (r.type === 'assistant' && m) {
+      const from = out.length;
+      for (const c of Array.isArray(m.content) ? m.content : []) {
+        if (c?.type === 'text') add(r, 'assistant', clip(c.text));
+        else if (c?.type === 'tool_use') add(r, 'tool', toolText(c.name, c.input));
+      }
+      const u = m.usage;
+      if (u && m.id && out.length > from) {
+        const prev = lastOf.get(m.id);
+        if (prev) delete prev.tokens;
+        const e = out[out.length - 1];
+        e.tokens = { input: n(u.input_tokens), cacheRead: n(u.cache_read_input_tokens), cacheWrite: n(u.cache_creation_input_tokens), output: n(u.output_tokens) };
+        lastOf.set(m.id, e);
+      }
+    } else if (r.type === 'system' && r.subtype === 'turn_duration') add(r, 'turn', `turn done${Number.isFinite(r.durationMs) ? ` (${Math.round(r.durationMs / 1000)}s)` : ''}`);
+
+  });
+}
+module.exports = { readTimeline };

package/agentmoni/lib/agents/codex/billing.js

@@ -0,0 +1,9 @@
+const os = require('node:os');
+const path = require('node:path');
+const { readFields } = require('../../json-fields.js');
+function readBilling({ home = os.homedir(), env = process.env, codexHome = env.CODEX_HOME ?? path.join(home, '.codex') } = {}) {
+  if (Object.hasOwn(env, 'OPENAI_API_KEY')) return 'api';
+  const mode = readFields(path.join(codexHome, 'auth.json'), ['auth_mode']).auth_mode;
+  return mode === 'chatgpt' ? 'subscription' : ['apikey', 'api_key', 'api-key'].includes(mode) ? 'api' : 'unknown';
+}
+module.exports = { readBilling };