@simonesiega/codex-limits 0.1.0

package/dist/index.js

@@ -0,0 +1,1062 @@
+// src/package/core/codex/paths.ts
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, normalize } from "node:path";
+
+// src/package/core/utils/env.ts
+function readEnvValue(env, key) {
+  const value = env[key]?.trim();
+  return value && value.length > 0 ? value : null;
+}
+function resolveEnvironment(env) {
+  return env ?? process.env;
+}
+
+// src/package/core/codex/paths.ts
+var CODEX_LIMITS_HOME = "CODEX_LIMITS_HOME";
+function getCodexHomeCandidatePaths(options = {}) {
+  const env = resolveEnvironment(options.env);
+  const home = options.homeDirectory ?? readEnvValue(env, "HOME") ?? readEnvValue(env, "USERPROFILE") ?? homedir();
+  const appData = options.appData ?? readEnvValue(env, "APPDATA");
+  const localAppData = options.localAppData ?? readEnvValue(env, "LOCALAPPDATA");
+  const paths = [];
+  const overrideHome = readEnvValue(env, CODEX_LIMITS_HOME);
+  const codexHome = readEnvValue(env, "CODEX_HOME");
+  appendCandidate(paths, overrideHome, "env");
+  appendCandidate(paths, codexHome, "env");
+  if (home) {
+    appendCandidate(paths, join(home, ".codex"), "default");
+    appendCandidate(paths, join(home, ".config", "codex"), "default");
+    appendCandidate(paths, join(home, "Library", "Application Support", "Codex"), "default");
+    appendCandidate(paths, join(home, "Library", "Application Support", "Parall", "Codex", ".codex"), "default");
+  }
+  appendCandidate(paths, appData ? join(appData, "Codex") : null, "default");
+  appendCandidate(paths, localAppData ? join(localAppData, "Codex") : null, "default");
+  return dedupePaths(paths);
+}
+async function detectCodexHome(options = {}) {
+  const env = resolveEnvironment(options.env);
+  const overrideHome = readEnvValue(env, CODEX_LIMITS_HOME);
+  const candidates = await Promise.all(getCodexHomeCandidatePaths(options).map(async (candidate) => ({
+    ...candidate,
+    exists: await canReadDirectory(candidate.path)
+  })));
+  return {
+    overrideHome: overrideHome ? normalize(overrideHome) : null,
+    candidates,
+    foundHome: candidates.find((candidate) => candidate.exists)?.path ?? null
+  };
+}
+function appendCandidate(paths, path, source) {
+  if (!path) {
+    return;
+  }
+  paths.push({ path: normalize(path), source });
+}
+async function canReadDirectory(path) {
+  try {
+    const details = await stat(path);
+    return details.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function dedupePaths(paths) {
+  const seen = new Set;
+  const result = [];
+  for (const candidate of paths) {
+    const normalizedPath = normalize(candidate.path);
+    const key = normalizedPath.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push({ path: normalizedPath, source: candidate.source });
+  }
+  return result;
+}
+
+// src/package/core/codex/session-reader.ts
+import { createReadStream } from "node:fs";
+import { readdir, stat as stat2 } from "node:fs/promises";
+import { join as join2, relative } from "node:path";
+import { createInterface } from "node:readline";
+var MAX_SESSION_DEPTH = 8;
+var MAX_SESSION_FILES_TO_PARSE = 20;
+var MAX_SESSION_FILE_BYTES = 25000000;
+var ROLLOUT_FILE_PATTERN = /^rollout-.*\.jsonl$/i;
+async function readCodexSessions(homePath) {
+  const sessionsRoot = join2(homePath, "sessions");
+  const warnings = [];
+  const candidates = await findSessionFiles(homePath, sessionsRoot, warnings);
+  const files = [];
+  let latestSnapshot = null;
+  for (const candidate of candidates.slice(0, MAX_SESSION_FILES_TO_PARSE)) {
+    const relativePath = relative(homePath, candidate.path);
+    if (candidate.size > MAX_SESSION_FILE_BYTES) {
+      warnings.push(`Skipped ${relativePath} because it is too large to inspect safely.`);
+      files.push(toSessionFile(candidate.path, relativePath, candidate.modifiedAtMs, false, "too-large"));
+      continue;
+    }
+    try {
+      const snapshot = await extractSnapshotFromSessionFile(homePath, candidate.path);
+      files.push(toSessionFile(candidate.path, relativePath, candidate.modifiedAtMs, snapshot !== null, null));
+      if (snapshot && !latestSnapshot) {
+        latestSnapshot = snapshot;
+      }
+    } catch {
+      warnings.push(`Could not inspect ${relativePath}.`);
+      files.push(toSessionFile(candidate.path, relativePath, candidate.modifiedAtMs, false, "read-error"));
+    }
+    if (latestSnapshot) {
+      break;
+    }
+  }
+  if (candidates.length > MAX_SESSION_FILES_TO_PARSE) {
+    warnings.push(`Skipped ${candidates.length - MAX_SESSION_FILES_TO_PARSE} older session files to keep inspection small.`);
+  }
+  if (candidates.length > 0 && !latestSnapshot) {
+    warnings.push("No token-count rate-limit snapshot was found in local Codex session logs.");
+  }
+  return { homePath, sessionsRoot, files, latestSnapshot, warnings };
+}
+async function findSessionFiles(homePath, sessionsRoot, warnings) {
+  const files = [];
+  await walkSessions(homePath, sessionsRoot, 0, files, warnings);
+  const candidates = (await Promise.all(files.map((path) => statSessionFile(homePath, path, warnings)))).filter(isSessionCandidate);
+  return candidates.sort((left, right) => right.modifiedAtMs - left.modifiedAtMs);
+}
+async function statSessionFile(homePath, path, warnings) {
+  try {
+    const details = await stat2(path);
+    return { path, modifiedAtMs: details.mtimeMs, size: details.size };
+  } catch {
+    warnings.push(`Could not inspect ${relative(homePath, path)}.`);
+    return null;
+  }
+}
+function isSessionCandidate(value) {
+  return value !== null;
+}
+async function walkSessions(homePath, currentPath, depth, files, warnings) {
+  if (depth > MAX_SESSION_DEPTH) {
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir(currentPath, { withFileTypes: true });
+  } catch {
+    if (depth > 0) {
+      warnings.push(`Could not inspect ${relative(homePath, currentPath)}.`);
+    }
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = join2(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      await walkSessions(homePath, entryPath, depth + 1, files, warnings);
+      continue;
+    }
+    if (entry.isFile() && ROLLOUT_FILE_PATTERN.test(entry.name)) {
+      files.push(entryPath);
+    }
+  }
+}
+async function extractSnapshotFromSessionFile(homePath, sessionFile) {
+  const relativePath = relative(homePath, sessionFile);
+  const reader = createInterface({
+    input: createReadStream(sessionFile, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let threadId = null;
+  let latest = null;
+  for await (const rawLine of reader) {
+    const entry = parseJsonLine(rawLine);
+    if (!entry) {
+      continue;
+    }
+    const metadataThreadId = readSessionThreadId(entry);
+    if (metadataThreadId) {
+      threadId = metadataThreadId;
+      continue;
+    }
+    const rateLimits = readRateLimits(entry);
+    if (!rateLimits) {
+      continue;
+    }
+    latest = {
+      sessionFile,
+      relativePath,
+      threadId,
+      eventTimestamp: readString(entry, "timestamp"),
+      rateLimits
+    };
+  }
+  return latest;
+}
+function parseJsonLine(rawLine) {
+  const line = rawLine.trim();
+  if (!line) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(line);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readSessionThreadId(entry) {
+  if (entry.type !== "session_meta" || !isRecord(entry.payload)) {
+    return null;
+  }
+  return readString(entry.payload, "id");
+}
+function readRateLimits(entry) {
+  if (entry.type !== "event_msg" || !isRecord(entry.payload)) {
+    return null;
+  }
+  if (entry.payload.type !== "token_count" || !isRecord(entry.payload.rate_limits)) {
+    return null;
+  }
+  return entry.payload.rate_limits;
+}
+function toSessionFile(path, relativePath, modifiedAtMs, hasSnapshot, error) {
+  return { path, relativePath, modifiedAtMs, hasSnapshot, error };
+}
+function readString(value, key) {
+  const field = value[key];
+  return typeof field === "string" && field.length > 0 ? field : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/package/core/codex/state-reader.ts
+import { readdir as readdir2, readFile, stat as stat3 } from "node:fs/promises";
+import { extname, join as join3, relative as relative2 } from "node:path";
+var MAX_DEPTH = 2;
+var MAX_FILES = 25;
+var MAX_FILE_BYTES = 1e6;
+var SENSITIVE_FILE_PATTERN = /(?:auth|token|cookie|session|secret|credential|api[-_]?key|keychain)/i;
+async function readCodexState(homePath) {
+  const warnings = [];
+  const paths = await findReadableStateFiles(homePath, warnings);
+  const files = [];
+  for (const filePath of paths.slice(0, MAX_FILES)) {
+    const relativePath = relative2(homePath, filePath);
+    try {
+      const details = await stat3(filePath);
+      if (details.size > MAX_FILE_BYTES) {
+        warnings.push(`Skipped ${relativePath} because it is too large to inspect safely.`);
+        continue;
+      }
+      const content = await readFile(filePath, "utf8");
+      const json = parseJson(content, relativePath, warnings);
+      files.push({
+        path: filePath,
+        relativePath,
+        json: json.value,
+        error: json.error
+      });
+    } catch {
+      warnings.push(`Could not read ${relativePath}.`);
+    }
+  }
+  if (paths.length > MAX_FILES) {
+    warnings.push(`Skipped ${paths.length - MAX_FILES} extra files to keep inspection small.`);
+  }
+  return { homePath, files, warnings };
+}
+async function findReadableStateFiles(homePath, warnings) {
+  const files = [];
+  await walk(homePath, homePath, 0, files, warnings);
+  return files.sort((left, right) => left.localeCompare(right));
+}
+async function walk(rootPath, currentPath, depth, files, warnings) {
+  if (depth > MAX_DEPTH || files.length >= MAX_FILES) {
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir2(currentPath, { withFileTypes: true });
+  } catch {
+    warnings.push(`Could not inspect ${relative2(rootPath, currentPath) || "."}.`);
+    return;
+  }
+  for (const entry of entries) {
+    if (files.length >= MAX_FILES) {
+      return;
+    }
+    const filePath = join3(currentPath, entry.name);
+    if (isSensitiveFileName(entry.name)) {
+      warnings.push("Skipped a sensitive-looking local file.");
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await walk(rootPath, filePath, depth + 1, files, warnings);
+      continue;
+    }
+    if (entry.isFile() && extname(entry.name).toLowerCase() === ".json") {
+      files.push(filePath);
+    }
+  }
+}
+function isSensitiveFileName(fileName) {
+  return SENSITIVE_FILE_PATTERN.test(fileName);
+}
+function parseJson(content, relativePath, warnings) {
+  try {
+    return { value: JSON.parse(content), error: null };
+  } catch {
+    warnings.push(`Could not parse JSON in ${relativePath}.`);
+    return { value: null, error: "invalid-json" };
+  }
+}
+
+// src/package/core/auth/codex-auth.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join4, normalize as normalize2 } from "node:path";
+async function resolveCodexCredentials(options) {
+  const env = resolveEnvironment(options.env);
+  const accessToken = readEnvValue(env, "CODEX_LIMITS_ACCESS_TOKEN");
+  const accountId = readEnvValue(env, "CODEX_LIMITS_ACCOUNT_ID");
+  if (accessToken || accountId) {
+    return accessToken && accountId ? { accessToken, accountId } : null;
+  }
+  const authFile = await resolveCodexAuthFile(options);
+  return authFile ? readAuthFile(authFile) : null;
+}
+async function resolveCodexAuthFile(options) {
+  if (options.authFile) {
+    return normalize2(options.authFile);
+  }
+  const detection = await detectCodexHome(options);
+  return detection.foundHome ? join4(detection.foundHome, "auth.json") : null;
+}
+async function readAuthFile(authPath) {
+  try {
+    const parsed = JSON.parse(await readFile2(authPath, "utf8"));
+    if (!isRecord2(parsed)) {
+      return null;
+    }
+    const tokens = isRecord2(parsed.tokens) ? parsed.tokens : parsed;
+    const accessToken = readString2(tokens, "access_token");
+    const accountId = readString2(tokens, "account_id");
+    return accessToken && accountId ? { accessToken, accountId } : null;
+  } catch {
+    return null;
+  }
+}
+function readString2(value, key) {
+  const field = value[key];
+  return typeof field === "string" && field.length > 0 ? field : null;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/package/core/utils/date-time.ts
+var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var MONTH_NAMES = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+function formatDuration(durationMs, options = {}) {
+  const includeSeconds = options.includeSeconds ?? false;
+  let remainingSeconds = Math.max(Math.floor(durationMs / 1000), 0);
+  const days = Math.floor(remainingSeconds / 86400);
+  remainingSeconds %= 86400;
+  const hours = Math.floor(remainingSeconds / 3600);
+  remainingSeconds %= 3600;
+  const minutes = Math.floor(remainingSeconds / 60);
+  const seconds = remainingSeconds % 60;
+  const parts = [];
+  if (days > 0) {
+    parts.push(`${days}d`);
+  }
+  if (hours > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes}m`);
+  }
+  if (includeSeconds && seconds > 0) {
+    parts.push(`${seconds}s`);
+  }
+  return parts.length > 0 ? parts.join(" ") : includeSeconds ? `${seconds}s` : "0m";
+}
+function parseDateValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const timestampMs = value < 10000000000 ? value * 1000 : value;
+    const date = new Date(timestampMs);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const trimmed = value.trim();
+    const numericValue = Number(trimmed);
+    if (Number.isFinite(numericValue)) {
+      return parseDateValue(numericValue);
+    }
+    const date = new Date(trimmed);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+function formatLongDate(date) {
+  return `${DAY_NAMES[date.getDay()]} ${date.getDate()} ${MONTH_NAMES[date.getMonth()]} ${date.getFullYear()}`;
+}
+
+// src/package/core/coupons/reset-coupons.ts
+var LIVE_RESET_COUPONS_ENDPOINT = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function getResetCoupons(options = {}) {
+  const endpoint = options.endpoint ?? LIVE_RESET_COUPONS_ENDPOINT;
+  const credentials = await resolveCodexCredentials(options);
+  if (!credentials) {
+    return unavailableCoupons(endpoint, [
+      "Live reset coupons require a readable Codex auth.json file or CODEX_LIMITS_ACCESS_TOKEN and CODEX_LIMITS_ACCOUNT_ID."
+    ]);
+  }
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  if (!fetchImplementation) {
+    return unavailableCoupons(endpoint, ["This runtime does not provide fetch for live reset coupon lookup."]);
+  }
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  try {
+    const response = await fetchImplementation(endpoint, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${credentials.accessToken}`,
+        "ChatGPT-Account-ID": credentials.accountId,
+        "OpenAI-Beta": "codex-1",
+        originator: "Codex Desktop"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return unavailableCoupons(endpoint, [`Live reset coupon endpoint returned HTTP ${response.status}.`]);
+    }
+    const payload = await response.json();
+    return parseResetCouponsPayload(payload, endpoint, options.now ?? new Date);
+  } catch {
+    return unavailableCoupons(endpoint, ["Live reset coupon lookup failed."]);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function unavailableCoupons(endpoint = LIVE_RESET_COUPONS_ENDPOINT, warnings = []) {
+  return {
+    status: "unavailable",
+    available: null,
+    earnedThisPeriod: null,
+    nextExpirationDate: null,
+    nextExpirationIn: null,
+    items: [],
+    warnings,
+    source: {
+      live: false,
+      label: "live Codex reset-credit endpoint",
+      endpoint
+    }
+  };
+}
+function parseResetCouponsPayload(payload, endpoint, now) {
+  if (!isRecord3(payload)) {
+    return unavailableCoupons(endpoint, ["Live reset coupon endpoint returned an unexpected payload."]);
+  }
+  const rawCredits = readArray(payload, ["credits", "reset_credits", "items"]);
+  const items = rawCredits.map((credit, index) => parseCouponItem(credit, index + 1, now)).filter((credit) => credit !== null).sort(compareCouponsByExpiry).map((credit, index) => ({ ...credit, index: index + 1 }));
+  const nextExpiring = items.find((item) => item.status === "available") ?? items[0] ?? null;
+  return {
+    status: "available",
+    available: readNumber(payload, ["available_count", "availableCount", "available"]),
+    earnedThisPeriod: readNumber(payload, ["total_earned_count", "earned_this_period", "earnedThisPeriod", "totalEarnedCount"]),
+    nextExpirationDate: nextExpiring?.expirationDate ?? null,
+    nextExpirationIn: nextExpiring?.expiresIn ?? null,
+    items,
+    warnings: [],
+    source: {
+      live: true,
+      label: "live Codex reset-credit endpoint",
+      endpoint
+    }
+  };
+}
+function parseCouponItem(value, index, now) {
+  if (!isRecord3(value)) {
+    return null;
+  }
+  const expiresAt = readString3(value, "expires_at") ?? readString3(value, "expiresAt");
+  const grantedAt = readString3(value, "granted_at") ?? readString3(value, "grantedAt");
+  const expiresAtDate = parseDateValue(expiresAt);
+  return {
+    index,
+    status: readString3(value, "status"),
+    grantedAt,
+    expiresAt,
+    expirationDate: expiresAtDate ? formatLongDate(expiresAtDate) : null,
+    expiresIn: expiresAtDate ? formatDuration(expiresAtDate.getTime() - now.getTime()) : null
+  };
+}
+function compareCouponsByExpiry(left, right) {
+  return dateSortValue(left.expiresAt) - dateSortValue(right.expiresAt);
+}
+function dateSortValue(value) {
+  const date = parseDateValue(value);
+  return date ? date.getTime() : Number.POSITIVE_INFINITY;
+}
+function readArray(value, keys) {
+  for (const key of keys) {
+    const field = value[key];
+    if (Array.isArray(field)) {
+      return field;
+    }
+  }
+  return [];
+}
+function readNumber(value, keys) {
+  for (const key of keys) {
+    const field = value[key];
+    if (typeof field === "number" && Number.isFinite(field)) {
+      return field;
+    }
+  }
+  return null;
+}
+function readString3(value, key) {
+  const field = value[key];
+  return typeof field === "string" && field.length > 0 ? field : null;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/package/core/usage/live.ts
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+
+// src/package/core/usage/normalizer.ts
+var MAX_SEARCH_DEPTH = 5;
+var FIVE_HOUR_LABEL = "5-hour usage limit";
+var WEEKLY_LABEL = "Weekly usage limit";
+var FIVE_HOUR_KEYS = ["fiveHour", "five_hour", "fiveHourWindow", "five_hour_window", "primary", "primaryWindow", "primary_window", "main", "mainWindow"];
+var WEEKLY_KEYS = ["weekly", "week", "weeklyWindow", "weekly_window", "secondary", "secondaryWindow", "secondary_window", "backup", "backupWindow"];
+var USED_KEYS = ["used_percent", "usedPercent", "used", "usage", "percentUsed", "usagePercent", "usagePercentage", "percent"];
+var REMAINING_KEYS = ["remaining_percent", "remainingPercent", "remaining", "percentRemaining", "availablePercent", "available_percentage"];
+var RESETS_AT_KEYS = ["resets_at", "resetsAt", "resetAt", "resetTime", "reset_at", "reset", "ends_at", "endsAt", "windowEnd"];
+var RESETS_IN_KEYS = ["resetsIn", "resetIn", "resets_in", "reset_in", "timeUntilReset"];
+function parseUsageFromSessions(sessions, now = new Date) {
+  const snapshot = sessions.latestSnapshot;
+  if (!snapshot) {
+    return unavailableLocalUsage(sessions.warnings);
+  }
+  return buildLocalUsageResult(parseUsageWindowsFromRateLimits(snapshot.rateLimits, now), sessions.warnings);
+}
+function parseUsageWindowsFromRateLimits(rateLimits, now = new Date) {
+  return {
+    fiveHour: parseUsageWindow(readRecord(rateLimits, FIVE_HOUR_KEYS), FIVE_HOUR_LABEL, now),
+    weekly: parseUsageWindow(readRecord(rateLimits, WEEKLY_KEYS), WEEKLY_LABEL, now)
+  };
+}
+function withUsageSource(result, source) {
+  return { ...result, source };
+}
+function buildUsageResult(windows, source, warnings = []) {
+  return { ...buildLocalUsageResult(windows, warnings), source };
+}
+function parseUsageFromState(state, now = new Date) {
+  let windows = { fiveHour: null, weekly: null };
+  for (const file of state.files) {
+    if (!file.json) {
+      continue;
+    }
+    const parsed = parseUsageFromUnknown(file.json, now);
+    windows = mergeUsageWindows(windows, parsed.windows);
+  }
+  return buildLocalUsageResult(windows, state.warnings);
+}
+function unavailableLocalUsage(warnings = []) {
+  return {
+    status: "unavailable",
+    windows: { fiveHour: null, weekly: null },
+    warnings
+  };
+}
+function mergeLocalUsage(primary, fallback) {
+  const windows = mergeUsageWindows(primary.windows, fallback.windows);
+  return buildLocalUsageResult(windows, [...primary.warnings, ...fallback.warnings]);
+}
+function parseUsageFromUnknown(value, now) {
+  if (!isRecord4(value)) {
+    return { windows: { fiveHour: null, weekly: null } };
+  }
+  const fiveHourSource = findRecord(value, FIVE_HOUR_KEYS);
+  const weeklySource = findRecord(value, WEEKLY_KEYS);
+  const fiveHour = parseUsageWindow(fiveHourSource ?? (weeklySource ? null : value), FIVE_HOUR_LABEL, now);
+  const weekly = parseUsageWindow(weeklySource, WEEKLY_LABEL, now);
+  return {
+    windows: { fiveHour, weekly }
+  };
+}
+function parseUsageWindow(value, label, now) {
+  if (!value) {
+    return null;
+  }
+  const used = toPercent(findValue(value, USED_KEYS, true));
+  const remaining = toPercent(findValue(value, REMAINING_KEYS, true));
+  const usedPercent = used ?? (remaining === null ? null : clampPercent(100 - remaining));
+  const remainingPercent = remaining ?? (used === null ? null : clampPercent(100 - used));
+  const resetValue = findValue(value, RESETS_AT_KEYS, true);
+  const resetDate = parseDateValue(resetValue);
+  const resetsAt = resetDate ? resetDate.toISOString() : readStringValue(resetValue);
+  const resetsIn = resetDate ? formatDuration(resetDate.getTime() - now.getTime()) : readStringValue(findValue(value, RESETS_IN_KEYS, true));
+  const window = { label, remainingPercent, usedPercent, resetsAt, resetsIn };
+  return hasWindowData(window) ? window : null;
+}
+function buildLocalUsageResult(windows, warnings) {
+  return {
+    status: statusForWindows(windows),
+    windows,
+    warnings
+  };
+}
+function statusForWindows(windows) {
+  const complete = isCompleteWindow(windows.fiveHour) && isCompleteWindow(windows.weekly);
+  if (complete) {
+    return "available";
+  }
+  if (hasWindowData(windows.fiveHour) || hasWindowData(windows.weekly)) {
+    return "partial";
+  }
+  return "unavailable";
+}
+function mergeUsageWindows(primary, fallback) {
+  return {
+    fiveHour: mergeUsageWindow(primary.fiveHour, fallback.fiveHour, FIVE_HOUR_LABEL),
+    weekly: mergeUsageWindow(primary.weekly, fallback.weekly, WEEKLY_LABEL)
+  };
+}
+function mergeUsageWindow(primary, fallback, label) {
+  if (!primary && !fallback) {
+    return null;
+  }
+  return {
+    label,
+    remainingPercent: primary?.remainingPercent ?? fallback?.remainingPercent ?? null,
+    usedPercent: primary?.usedPercent ?? fallback?.usedPercent ?? null,
+    resetsAt: primary?.resetsAt ?? fallback?.resetsAt ?? null,
+    resetsIn: primary?.resetsIn ?? fallback?.resetsIn ?? null
+  };
+}
+function hasWindowData(window) {
+  return window !== null && (window.remainingPercent !== null || window.usedPercent !== null || window.resetsAt !== null || window.resetsIn !== null);
+}
+function isCompleteWindow(window) {
+  return window !== null && window.remainingPercent !== null && window.usedPercent !== null && (window.resetsAt !== null || window.resetsIn !== null);
+}
+function findRecord(value, keys, depth = 0) {
+  if (depth > MAX_SEARCH_DEPTH) {
+    return null;
+  }
+  for (const key of keys) {
+    const nested = value[key];
+    if (isRecord4(nested)) {
+      return nested;
+    }
+  }
+  for (const nested of Object.values(value)) {
+    if (!isRecord4(nested)) {
+      continue;
+    }
+    const found = findRecord(nested, keys, depth + 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+function readRecord(value, keys) {
+  for (const key of keys) {
+    const nested = value[key];
+    if (isRecord4(nested)) {
+      return nested;
+    }
+  }
+  return null;
+}
+function findValue(value, keys, allowNested, depth = 0) {
+  if (depth > MAX_SEARCH_DEPTH) {
+    return;
+  }
+  for (const key of keys) {
+    if (key in value) {
+      return value[key];
+    }
+  }
+  if (!allowNested) {
+    return;
+  }
+  for (const nested of Object.values(value)) {
+    if (!isRecord4(nested)) {
+      continue;
+    }
+    const found = findValue(nested, keys, allowNested, depth + 1);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return;
+}
+function toPercent(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return clampPercent(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const trimmed = value.trim();
+    const normalized = trimmed.endsWith("%") ? trimmed.slice(0, -1) : trimmed;
+    const parsed = Number(normalized);
+    return Number.isFinite(parsed) ? clampPercent(parsed) : null;
+  }
+  return null;
+}
+function clampPercent(value) {
+  return Math.round(Math.min(Math.max(value, 0), 100) * 10) / 10;
+}
+function readStringValue(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+  return null;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/package/core/usage/live.ts
+var LIVE_USAGE_ENDPOINT = "https://chatgpt.com/backend-api/codex/usage";
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+var UNAVAILABLE_SOURCE = { kind: "unavailable", label: "Unavailable" };
+async function getLiveUsage(options = {}) {
+  const endpoint = resolveUsageEndpoint(options);
+  const credentials = await resolveCodexCredentials(options);
+  if (!credentials) {
+    return unavailableLiveUsage(["Live usage requires Codex authentication."]);
+  }
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  if (!fetchImplementation) {
+    return unavailableLiveUsage(["This runtime does not provide fetch for live usage lookup."]);
+  }
+  const controller = new AbortController;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const headers = buildUsageHeaders(credentials);
+  try {
+    const response = await fetchImplementation(endpoint, {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+    return await parseLiveUsageResponse(response, endpoint, timeoutMs, headers, options.now ?? new Date);
+  } catch {
+    return await getLiveUsageWithNativeRequest(endpoint, timeoutMs, headers, options.now ?? new Date, "Live usage lookup failed.");
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function buildUsageHeaders(credentials) {
+  return {
+    Authorization: `Bearer ${credentials.accessToken}`,
+    "ChatGPT-Account-ID": credentials.accountId,
+    "OpenAI-Beta": "codex-1",
+    originator: "Codex Desktop",
+    Accept: "application/json",
+    "User-Agent": "Codex Desktop",
+    Referer: "https://chatgpt.com/codex/cloud/settings/analytics",
+    Origin: "https://chatgpt.com"
+  };
+}
+async function parseLiveUsageResponse(response, endpoint, timeoutMs, headers, now) {
+  if (response.ok) {
+    return parseLiveUsagePayload(await response.json(), endpoint, now);
+  }
+  return getLiveUsageWithNativeRequest(endpoint, timeoutMs, headers, now, `Live usage endpoint returned HTTP ${response.status}.`);
+}
+async function getLiveUsageWithNativeRequest(endpoint, timeoutMs, headers, now, fallbackWarning) {
+  try {
+    const response = await requestJson(endpoint, headers, timeoutMs);
+    if (!response.ok) {
+      return unavailableLiveUsage([`Live usage endpoint returned HTTP ${response.status}.`]);
+    }
+    return parseLiveUsagePayload(await response.json(), endpoint, now);
+  } catch {
+    return unavailableLiveUsage([fallbackWarning]);
+  }
+}
+function resolveUsageEndpoint(options) {
+  const env = resolveEnvironment(options.env);
+  return options.usageEndpoint ?? readEnvValue(env, "CODEX_LIMITS_USAGE_ENDPOINT") ?? LIVE_USAGE_ENDPOINT;
+}
+function parseLiveUsagePayload(payload, endpoint, now) {
+  const rateLimits = findRateLimits(payload) ?? buildRateLimitsFromWindowArray(payload);
+  if (!rateLimits) {
+    return unavailableLiveUsage(["Live usage endpoint returned an unexpected payload."]);
+  }
+  return buildUsageResult(parseUsageWindowsFromRateLimits(rateLimits, now), { kind: "api", label: "API", endpoint });
+}
+function unavailableLiveUsage(warnings) {
+  return buildUsageResult({ fiveHour: null, weekly: null }, UNAVAILABLE_SOURCE, warnings);
+}
+function findRateLimits(value, depth = 0) {
+  if (!isRecord5(value) || depth > 5) {
+    return null;
+  }
+  const direct = value.rate_limits ?? value.rateLimits ?? value.rate_limit ?? value.rateLimit;
+  if (isRecord5(direct)) {
+    return direct;
+  }
+  if (isRecord5(value.primary) || isRecord5(value.secondary) || isRecord5(value.primary_window) || isRecord5(value.secondary_window)) {
+    return value;
+  }
+  for (const nested of Object.values(value)) {
+    const found = findRateLimits(nested, depth + 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+function buildRateLimitsFromWindowArray(value, depth = 0) {
+  if (depth > 5) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    const primary = value.find((item) => isUsageWindowRecord(item, "primary"));
+    const secondary = value.find((item) => isUsageWindowRecord(item, "secondary"));
+    return primary || secondary ? { primary, secondary } : null;
+  }
+  if (!isRecord5(value)) {
+    return null;
+  }
+  for (const nested of Object.values(value)) {
+    const found = buildRateLimitsFromWindowArray(nested, depth + 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+function isUsageWindowRecord(value, kind) {
+  if (!isRecord5(value)) {
+    return false;
+  }
+  const label = String(value.type ?? value.kind ?? value.name ?? value.label ?? value.window ?? "").toLowerCase();
+  if (kind === "primary" && (label.includes("primary") || label.includes("5-hour") || label.includes("five"))) {
+    return true;
+  }
+  if (kind === "secondary" && (label.includes("secondary") || label.includes("weekly") || label.includes("week"))) {
+    return true;
+  }
+  const minutes = value.window_minutes ?? value.windowMinutes ?? value.window_length_minutes ?? value.windowLengthMinutes;
+  return kind === "primary" ? minutes === 300 : minutes === 10080;
+}
+function requestJson(endpoint, headers, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint);
+    const request = (url.protocol === "http:" ? httpRequest : httpsRequest)(url, {
+      method: "GET",
+      headers,
+      timeout: timeoutMs
+    }, (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      response.on("end", () => {
+        const body = Buffer.concat(chunks).toString("utf8");
+        resolve({
+          ok: response.statusCode !== undefined && response.statusCode >= 200 && response.statusCode < 300,
+          status: response.statusCode ?? 0,
+          json: async () => JSON.parse(body)
+        });
+      });
+    });
+    request.on("timeout", () => {
+      request.destroy(new Error("Live usage request timed out."));
+    });
+    request.on("error", reject);
+    request.end();
+  });
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/package/core/utils/redact.ts
+var SENSITIVE_PATTERNS = [
+  /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+  /(?:access_token|refresh_token|api_key|account_id|authorization)\s*[:=]\s*[A-Za-z0-9._~+/=-]+/gi,
+  /sk-[A-Za-z0-9]{10,}/g
+];
+function redactSensitiveText(value) {
+  let redacted = value;
+  for (const pattern of SENSITIVE_PATTERNS) {
+    redacted = redacted.replace(pattern, "[redacted]");
+  }
+  return redacted;
+}
+function redactWarnings(warnings) {
+  return warnings.map(redactSensitiveText);
+}
+
+// src/package/core/limits.ts
+var LOCAL_USAGE_SOURCE = { kind: "local", label: "Local" };
+async function getCodexLimits(options = {}) {
+  const usage = await getUsageLimits(options);
+  const coupons = options.includeCoupons === false ? null : await getResetCoupons(options);
+  const warnings = redactWarnings([...usage.warnings, ...coupons?.warnings ?? []]);
+  return {
+    windows: usage.windows,
+    usageSource: usage.source,
+    coupons,
+    warnings
+  };
+}
+async function getUsageLimits(options = {}) {
+  const live = await getLiveUsage(options);
+  if (live.status === "available") {
+    return live;
+  }
+  const local = withUsageSource(await getLocalUsage(options), LOCAL_USAGE_SOURCE);
+  return local.status !== "unavailable" ? local : { ...local, warnings: [...live.warnings, ...local.warnings] };
+}
+async function getLocalUsage(options = {}) {
+  const now = options.now ?? new Date;
+  const detection = await detectCodexHome(options);
+  if (!detection.foundHome) {
+    return unavailableLocalUsage(["No readable local Codex home directory was found."]);
+  }
+  const sessions = await readCodexSessions(detection.foundHome);
+  const sessionUsage = parseUsageFromSessions(sessions, now);
+  const state = await readCodexState(detection.foundHome);
+  const stateUsage = parseUsageFromState(state, now);
+  return mergeLocalUsage(sessionUsage, stateUsage);
+}
+
+// src/agents/opencode/format.ts
+var BAR_WIDTH = 22;
+function formatOpencodeLimits(result) {
+  return [
+    ...formatWindow("5-hour", result.windows.fiveHour),
+    "",
+    ...formatWindow("Weekly", result.windows.weekly),
+    "",
+    ...formatCredits(result),
+    ...formatWarnings(result.warnings)
+  ].join(`
+`);
+}
+function formatWindow(title, window) {
+  const percent = window?.remainingPercent ?? null;
+  return [
+    `${title}  ${statusLabel(percent)}`,
+    `Remaining  ${remainingLabel(percent)}`,
+    progressBar(percent),
+    `Reset      ${window?.resetsIn ? `in ${window.resetsIn}` : "unknown"}`
+  ];
+}
+function remainingLabel(value) {
+  return value === null ? "Unknown" : `${Math.round(value)}% remaining`;
+}
+function progressBar(value) {
+  const percent = clampPercent2(value);
+  const filled = Math.round(percent / 100 * BAR_WIDTH);
+  const empty = Math.max(BAR_WIDTH - filled, 0);
+  return `[${"=".repeat(filled)}${" ".repeat(empty)}] ${Math.round(percent)}%`;
+}
+function formatCredits(result) {
+  const available = result.coupons?.available;
+  const expires = formatExpiration(result);
+  const lines = [`Reset credits  ${available === null || available === undefined ? "Unknown" : creditLabel(available)}`];
+  if (expires !== "unknown") {
+    lines.push(`Next expires   ${expires}`);
+  }
+  return lines;
+}
+function creditLabel(value) {
+  const suffix = value === 1 ? "credit available" : "credits available";
+  return `${value} ${suffix}`;
+}
+function formatWarnings(warnings) {
+  if (warnings.length === 0) {
+    return [];
+  }
+  return ["", "Warnings", ...warnings.map((warning) => `- ${warning}`)];
+}
+function statusLabel(value) {
+  if (value === null)
+    return "Unknown";
+  if (value >= 50)
+    return "Healthy";
+  if (value >= 15)
+    return "Low";
+  return "Critical";
+}
+function clampPercent2(value) {
+  if (value === null) {
+    return 0;
+  }
+  return Math.min(Math.max(value, 0), 100);
+}
+function formatExpiration(result) {
+  const expiresIn = result.coupons?.nextExpirationIn;
+  const expiresAt = result.coupons?.nextExpirationDate;
+  if (expiresIn && expiresAt) {
+    return `${expiresIn} (${expiresAt})`;
+  }
+  return expiresIn ?? expiresAt ?? "unknown";
+}
+
+// src/agents/opencode/plugin.tsx
+var TITLE = "Codex Limits";
+var DESCRIPTION = "Check Codex limits, resets, and credits.";
+var module = {
+  id: "codex-limits",
+  tui: async (api) => {
+    api.command?.register(() => [
+      {
+        title: TITLE,
+        value: "codex-limits.show",
+        description: DESCRIPTION,
+        category: "Codex",
+        slash: { name: "codex-limits" },
+        onSelect: async (dialog) => {
+          dialog?.clear();
+          api.ui.dialog.clear();
+          await nextFrame();
+          const target = api.ui.dialog;
+          target.setSize("large");
+          target.replace(() => alert(api, "Loading Codex limits..."));
+          try {
+            const result = await getCodexLimits();
+            target.replace(() => alert(api, formatOpencodeLimits(result)));
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Could not load Codex limits.";
+            api.ui.toast({ variant: "error", title: TITLE, message });
+            target.replace(() => alert(api, message));
+          }
+        }
+      }
+    ]);
+  }
+};
+function alert(api, message) {
+  return api.ui.DialogAlert({ title: TITLE, message });
+}
+function nextFrame() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+var plugin_default = module;
+var tui = module.tui;
+export {
+  tui,
+  plugin_default as default
+};