march-cli 0.1.34 → 0.1.36

package/src/main.mjs

@@ -1,46 +1,18 @@
 import { homedir } from "node:os";
-import { join, resolve, basename, relative } from "node:path";
-import { existsSync, mkdirSync } from "node:fs";
+import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseCliArgs, showHelp } from "./cli/args.mjs";
-import { createUI } from "./cli/ui.mjs";
-import { createPermissionController, MODE } from "./cli/permissions.mjs";
-import { loadKeybindings } from "./cli/input/keybindings.mjs";
-import { createInputHistoryStore } from "./cli/input/history-store.mjs";
-import { createModeState } from "./cli/input/mode-state.mjs";
-import { loadPromptTemplates } from "./cli/input/prompt-templates.mjs";
 import { runInteractiveRepl, runSingleShotPrompt } from "./cli/repl-loop.mjs";
 import { closeMarchRuntime } from "./cli/startup/runtime-close.mjs";
-import { createStatusLineUpdater } from "./cli/status-line-updater.mjs";
-import { wireTuiHandlers } from "./cli/tui/tui-handlers.mjs";
-import { createMarchAuthStorage } from "./auth/storage.mjs";
-import { runLoginCommand } from "./auth/login-command.mjs";
-import { createRuntimeRunner } from "./cli/startup/create-runtime-runner.mjs";
-import { createCliShellRuntime } from "./shell/cli-runtime.mjs";
-import { MarkdownMemoryStore } from "./memory/markdown-store.mjs";
-import { createMarkdownMemoryTools } from "./memory/markdown-tools.mjs";
+import { createCliAppRuntime } from "./cli/startup/app-runtime.mjs";
+import { formatStartupBanner } from "./cli/startup/startup-banner.mjs";
 import { loadDotEnv } from "./config/dotenv.mjs";
 import { loadConfig } from "./config/loader.mjs";
-import { discoverProjectExtensionPaths } from "./extensions/discovery.mjs";
-import { loadProjectLifecycleHookManifests } from "./extensions/lifecycle-manifest.mjs";
-import { loadOrCreateProjectId, resumeStartupSession } from "./cli/startup/startup-session.mjs";
-import { formatStartupBanner } from "./cli/startup/startup-banner.mjs";
-import { initializeMcp } from "./mcp/index.mjs";
-import { createWebToolsFromConfig } from "./web/tools.mjs";
-import { createModelContextDumper } from "./debug/model-context-dumper.mjs";
-import { createLogger, installProcessLogHandlers } from "./debug/logger.mjs";
-import { defaultProfilePaths, ensureProfileFiles } from "./context/profiles.mjs";
-import { runProviderCommand } from "./provider/command.mjs";
-import { runWebSearchConfigCommand } from "./web/config-command.mjs";
-import { createDesktopTurnNotifier } from "./notification/desktop-notifier.mjs";
 import { registerSuperGrokOAuthProvider } from "./supergrok/oauth-provider.mjs";
 import { installNetworkEnvironment } from "./network/environment.mjs";
-import { runMemoryCommand } from "./memory/command.mjs";
-import { normalizeRemoteMemorySources } from "./memory/remote/config.mjs";
-import { resolveMemoryRoot } from "./memory/root.mjs";
-import { runConfiguredCliCommand } from "./cli/startup/configured-command.mjs";
+import { runEarlyCliCommand } from "./cli/startup/early-command.mjs";
 import { maybeRunGatewayDaemonCommand } from "./cli/startup/gateway-daemon-command.mjs";
-import { ensureBrowserDaemon } from "./browser/client/lifecycle.mjs";
+
 export async function run(argv) {
   const cwd = process.cwd();
   loadDotEnv(cwd);
@@ -56,239 +28,72 @@ export async function run(argv) {
   const stateRoot = join(homedir(), ".march");
   const useRuntimeProcess = process.env.MARCH_RUNTIME_PROCESS !== "0";
   installNetworkEnvironment(config.network);
-  if (args.command?.name === "login") {
-    try {
-      return await runLoginCommand({
-        providerId: args.command.args[0] ?? args.provider,
-      });
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}\n`);
-      return 1;
-    }
-  }
-  if (args.command?.name === "provider") {
-    return await runProviderCommand(args);
-  }
-  if (args.command?.name === "websearch") {
-    if (args.providerConfig) return await runWebSearchConfigCommand({ homeDir: homedir() });
-    process.stderr.write("Usage: march websearch --config\n");
-    return 1;
-  }
-  if (args.command?.name === "memory") {
-    args.memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
-    return await runMemoryCommand(args, { homeDir: homedir() });
-  }
-  const configuredCommand = await runConfiguredCliCommand(args, { config, cwd, stateRoot });
-  if (configuredCommand.handled) return configuredCommand.code;
-  if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
-  await ensureBrowserDaemon({ stateRoot }).catch(() => {});
-  const logger = createLogger({ logDir: join(stateRoot, "logs") });
-  installProcessLogHandlers(logger);
-  logger.event("process.start", {
-    cwd,
-    argv,
-    version: process.version,
-    platform: process.platform,
-    logPath: logger.path,
-  });
 
-  const provider = args.provider ?? config.provider ?? null;
-  const serviceTier = config.serviceTier ?? null;
-  const model = args.model ?? config.model ?? null;
-  const extensionPaths = [
-    ...discoverProjectExtensionPaths(cwd),
-    ...args.extensions.map((extensionPath) => resolve(cwd, extensionPath)),
-  ];
-  const lifecycleManifests = loadProjectLifecycleHookManifests(cwd);
-  const keybindingConfig = loadKeybindings(cwd);
-  const promptTemplateConfig = loadPromptTemplates(cwd);
-  const authConfig = createMarchAuthStorage({ provider: provider ?? "deepseek", providers: config.providers, cwd });
+  const earlyCommand = await runEarlyCliCommand(args, { config, cwd, stateRoot });
+  if (earlyCommand.handled) return earlyCommand.code;
 
-  if (!authConfig.hasAuth) {
-    process.stderr.write("Error: no providers configured. Run: march provider --config\n");
-    return 1;
-  }
-
-  const projectMarchDir = resolve(cwd, ".march");
-  if (!existsSync(projectMarchDir)) mkdirSync(projectMarchDir, { recursive: true });
-  const inputHistoryStore = createInputHistoryStore({ path: join(projectMarchDir, "input-history.json") });
-  const modeState = createModeState();
-  const namespace = loadOrCreateProjectId(projectMarchDir);
-  const memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
-  const profilePaths = defaultProfilePaths();
-  ensureProfileFiles(profilePaths);
-  const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
-  const remoteMemorySources = normalizeRemoteMemorySources(config);
-  const memoryTools = createMarkdownMemoryTools(memoryStore, { remoteSources: remoteMemorySources });
-  const currentProject = basename(cwd);
-  const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
+  const app = await createCliAppRuntime({ args, config, cwd, argv, stateRoot, useRuntimeProcess });
+  if (!app.ok) return app.code;
 
-  const mcpInit = useRuntimeProcess
-    ? { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] }
-    : await initializeMcp({ projectDir: cwd });
-  const { clientManager: mcpClientManager, mcpTools, mcpInjections } = mcpInit;
-  for (const { server, error } of mcpInit.errors) {
-    if (args.json) {
-      // errors will be surfaced in diagnostics via runner status
-    } else {
-      process.stderr.write(`[mcp] ${server}: ${error}\n`);
-    }
-  }
-
-  const webTools = createWebToolsFromConfig(config);
-  const turnNotifier = createDesktopTurnNotifier({ enabled: Boolean(config.notifications?.turnEnd), config: config.notifications });
-  const permissionMode = args.permissionMode ?? MODE.BYPASS;
-  const permissionController = createPermissionController({ mode: permissionMode });
-  const usePiSessions = true;
-  const usePiRuntimeHost = true;
-  const sessionSource = "pi";
-  const sessionsRoot = join(projectMarchDir, "sessions");
-  const sessionState = {
-    sessionId: args.resume ?? Date.now().toString(36),
-    sessionDir: null,
-  };
-  sessionState.sessionDir = join(sessionsRoot, sessionState.sessionId);
-  const contextDumpRoot = resolve(projectMarchDir, "context-dumps", sessionState.sessionId);
-  const modelContextDumper = createModelContextDumper({
-    enabled: args.dumpContext,
-    rootDir: contextDumpRoot,
-  });
-
-  const ui = createUI({
-    json: args.json,
-    cwd,
-    keybindings: keybindingConfig.keybindings,
-    promptTemplates: promptTemplateConfig.templates,
-    shellRuntime,
-    historyStore: inputHistoryStore,
-  });
-
-  // Esc to abort current turn
-  let turnRunning = false;
-  let refreshStatusBar = null;
-
-  const runnerOptions = {
-    cwd,
-    modelId: model,
-    provider,
-    serviceTier,
-    providers: config.providers,
+  const gatewayDaemonCommand = await maybeRunGatewayDaemonCommand(args, {
     config,
-    stateRoot,
-    memoryRoot,
-    profilePaths,
-    namespace,
-    projectMarchDir,
-    extensionPaths,
-    permissionMode,
-    shellRuntime: Boolean(shellRuntime),
-    lifecycleHooks: lifecycleManifests.hooks,
-    lifecycleDiagnostics: lifecycleManifests.diagnostics,
-    modelContextDumper: { enabled: args.dumpContext, rootDir: contextDumpRoot },
-    remoteMemorySources,
-  };
-  const runner = await createRuntimeRunner({
-    useRuntimeProcess,
-    runnerOptions,
-    ui,
-    memoryStore,
-    memoryTools,
-    shellRuntime,
-    mcpTools,
-    mcpInjections,
-    mcpClientManager,
-    webTools,
-    usePiSessions,
-    usePiRuntimeHost,
-    authStorage: authConfig.authStorage,
-    permissionController,
-    modelContextDumper,
-    turnNotifier,
-    logger,
-    refreshStatusBar: (...args) => refreshStatusBar?.(...args),
-  });
-
-  refreshStatusBar = createStatusLineUpdater({
-    ui,
-    runner,
-    sessionState,
-    sessionSource,
-    getMode: () => modeState.get(),
-  });
-  const initialContextTokens = typeof runner.estimateContextTokens === "function"
-    ? await runner.estimateContextTokens("")
-    : null;
-  refreshStatusBar(initialContextTokens ? { contextTokens: initialContextTokens } : undefined);
-
-  wireTuiHandlers({
-    ui,
-    runner,
-    sessionState,
-    projectMarchDir,
-    refreshStatusBar,
-    isTurnRunning: () => turnRunning,
-    modeState,
-  });
-
-  const startupResume = await resumeStartupSession({
-    resumeId: args.resume,
-    runner,
-    sessionState,
-    projectMarchDir,
-    ui,
+    cwd,
+    runner: app.runner,
+    currentProject: app.currentProject,
+    memoryStore: app.memoryStore,
+    ui: app.ui,
+    logger: app.logger,
   });
-  refreshStatusBar();
-  const gatewayDaemonCommand = await maybeRunGatewayDaemonCommand(args, { config, cwd, runner, currentProject, memoryStore, ui, logger });
   if (gatewayDaemonCommand.handled) return gatewayDaemonCommand.code;
 
   if (args.prompt) {
-    turnRunning = true;
+    app.setTurnRunning(true);
     try {
       await runSingleShotPrompt({
         prompt: args.prompt,
-        runner,
-        memoryStore,
-        currentProject,
-        ui,
-        sessionState,
-        refreshStatusBar,
-        modeState,
+        runner: app.runner,
+        memoryStore: app.memoryStore,
+        currentProject: app.currentProject,
+        ui: app.ui,
+        sessionState: app.sessionState,
+        refreshStatusBar: app.refreshStatusBar,
+        modeState: app.modeState,
       });
     } finally {
-      turnRunning = false;
-      await closeMarchRuntime({ runner, memoryStore, ui, logger, blankLine: true });
+      app.setTurnRunning(false);
+      await closeMarchRuntime({ runner: app.runner, memoryStore: app.memoryStore, ui: app.ui, logger: app.logger, blankLine: true });
     }
-    logger.event("process.exit", { code: 0 });
+    app.logger.event("process.exit", { code: 0 });
     return 0;
   }
 
-  const dumpContextPath = args.dumpContext ? relative(cwd, contextDumpRoot) : null;
-  if (startupResume.transcriptTurns?.length > 0) ui.restoreTranscript?.(startupResume.transcriptTurns);
-  for (const line of formatStartupBanner({ cwd, modelId: runner.engine.modelId, thinkingLevel: runner.engine.thinkingLevel, mode: modeState.get(), dumpContextPath })) ui.writeln(line);
+  const dumpContextPath = args.dumpContext ? relative(cwd, app.contextDumpRoot) : null;
+  if (app.startupResume.transcriptTurns?.length > 0) app.ui.restoreTranscript?.(app.startupResume.transcriptTurns);
+  for (const line of formatStartupBanner({ cwd, modelId: app.runner.engine.modelId, thinkingLevel: app.runner.engine.thinkingLevel, mode: app.modeState.get(), dumpContextPath })) app.ui.writeln(line);
   try {
     await runInteractiveRepl({
       cwd,
       args,
-      ui,
-      runner,
-      memoryStore,
-      currentProject,
-      sessionState,
-      sessionsRoot,
-      projectMarchDir,
-      sessionSource,
-      extensionPaths,
-      keybindingConfig,
-      promptTemplateConfig,
-      renderStartupBanner: () => formatStartupBanner({ cwd, modelId: runner.engine.modelId, thinkingLevel: runner.engine.thinkingLevel, mode: modeState.get(), dumpContextPath }),
-      refreshStatusBar,
-      setTurnRunning: (value) => { turnRunning = value; },
-      modeState,
+      ui: app.ui,
+      runner: app.runner,
+      memoryStore: app.memoryStore,
+      currentProject: app.currentProject,
+      sessionState: app.sessionState,
+      sessionsRoot: app.sessionsRoot,
+      projectMarchDir: app.projectMarchDir,
+      sessionSource: app.sessionSource,
+      extensionPaths: app.extensionPaths,
+      keybindingConfig: app.keybindingConfig,
+      promptTemplateConfig: app.promptTemplateConfig,
+      renderStartupBanner: () => formatStartupBanner({ cwd, modelId: app.runner.engine.modelId, thinkingLevel: app.runner.engine.thinkingLevel, mode: app.modeState.get(), dumpContextPath }),
+      refreshStatusBar: app.refreshStatusBar,
+      setTurnRunning: app.setTurnRunning,
+      modeState: app.modeState,
     });
   } finally {
-    await closeMarchRuntime({ runner, memoryStore, ui, logger });
+    await closeMarchRuntime({ runner: app.runner, memoryStore: app.memoryStore, ui: app.ui, logger: app.logger });
   }
-  logger.event("process.exit", { code: 0 });
+  app.logger.event("process.exit", { code: 0 });
   return 0;
 }
 

package/src/provider/quota/codex.mjs

@@ -0,0 +1,278 @@
+import { getOAuthProvider } from "@earendil-works/pi-ai/oauth";
+
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+
+export async function fetchOpenAICodexQuota({ authStorage, model, fetchImpl = fetch, now = new Date() } = {}) {
+  const token = await resolveCodexAccessToken(authStorage);
+  const accountId = resolveCodexAccountId(authStorage, token);
+  const response = await fetchImpl(CODEX_USAGE_URL, {
+    method: "GET",
+    headers: buildCodexUsageHeaders(token, accountId),
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Codex quota request failed (${response.status}): ${text || response.statusText}`);
+  }
+  const payload = await response.json();
+  return normalizeCodexQuotaPayload(payload, { model, capturedAt: now.toISOString() });
+}
+
+export function normalizeCodexQuotaPayload(payload, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const snapshots = Array.isArray(payload) ? payload : snapshotsFromCodexUsagePayload(payload);
+  return normalizeCodexQuotaSnapshots(snapshots, { model, capturedAt });
+}
+
+export function normalizeCodexQuotaSnapshots(snapshots, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const limits = snapshots.map(normalizeSnapshot).filter((limit) => limit.windows.length > 0);
+  if (limits.length === 0) return null;
+  return {
+    providerId: "openai-codex",
+    modelId: model?.id ?? null,
+    label: "GPT usage",
+    planType: firstNonEmpty(snapshots.map((snapshot) => readField(snapshot, "planType", "plan_type"))),
+    capturedAt,
+    limits,
+  };
+}
+
+export function parseOpenAICodexQuotaHeaders(headers, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const normalized = normalizeHeaders(headers);
+  const limitIds = new Set(["codex"]);
+  for (const name of Object.keys(normalized)) {
+    const prefix = name.endsWith("-primary-used-percent") ? name.slice(2, -"-primary-used-percent".length) : null;
+    if (prefix) limitIds.add(prefix.replaceAll("-", "_"));
+  }
+  const snapshots = [...limitIds]
+    .map((limitId) => snapshotFromHeaders(normalized, limitId))
+    .filter((snapshot) => snapshot.primary || snapshot.secondary || snapshot.credits);
+  return normalizeCodexQuotaSnapshots(snapshots, { model, capturedAt });
+}
+
+export function parseOpenAICodexQuotaEvent(payload, { model = null, capturedAt = new Date().toISOString() } = {}) {
+  const event = typeof payload === "string" ? parseJson(payload) : payload;
+  if (!event || event.type !== "codex.rate_limits") return null;
+  const snapshot = {
+    limitId: readField(event, "metered_limit_name", "limit_name") ?? "codex",
+    limitName: null,
+    primary: mapWindow(readField(readField(event, "rate_limits", "rateLimits"), "primary")),
+    secondary: mapWindow(readField(readField(event, "rate_limits", "rateLimits"), "secondary")),
+    credits: readField(event, "credits") ?? null,
+    planType: readField(event, "plan_type", "planType") ?? null,
+    rateLimitReachedType: null,
+  };
+  return normalizeCodexQuotaSnapshots([snapshot], { model, capturedAt });
+}
+
+async function resolveCodexAccessToken(authStorage) {
+  const token = await authStorage?.getApiKey?.("openai-codex", { includeFallback: false });
+  if (token) return token;
+  const credentials = authStorage?.get?.("openai-codex");
+  if (!credentials) throw new Error("OpenAI Codex not authenticated. Run: march login openai-codex");
+  const provider = getOAuthProvider("openai-codex");
+  if (!provider) throw new Error("OpenAI Codex OAuth provider is not available");
+  return provider.getApiKey(credentials);
+}
+
+function resolveCodexAccountId(authStorage, token) {
+  const credentials = authStorage?.get?.("openai-codex");
+  return credentials?.accountId ?? credentials?.chatgpt_account_id ?? extractAccountId(token);
+}
+
+function extractAccountId(token) {
+  try {
+    const [, payload] = String(token).split(".");
+    const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    const accountId = parsed?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
+    if (typeof accountId === "string" && accountId) return accountId;
+  } catch {}
+  throw new Error("Failed to extract Codex account ID from token");
+}
+
+function buildCodexUsageHeaders(token, accountId) {
+  return {
+    authorization: `Bearer ${token}`,
+    "chatgpt-account-id": accountId,
+    originator: "march",
+    "user-agent": "march-cli",
+    accept: "application/json",
+  };
+}
+
+function snapshotsFromCodexUsagePayload(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const planType = readField(payload, "planType", "plan_type") ?? null;
+  const reached = readField(payload, "rateLimitReachedType", "rate_limit_reached_type") ?? null;
+  const snapshots = [makeSnapshot({
+    limitId: "codex",
+    limitName: null,
+    rateLimit: unwrap(readField(payload, "rateLimit", "rate_limit")),
+    credits: unwrap(readField(payload, "credits")),
+    planType,
+    rateLimitReachedType: unwrap(reached)?.kind ?? reached,
+  })];
+  const additional = readField(payload, "additionalRateLimits", "additional_rate_limits");
+  if (Array.isArray(additional)) {
+    for (const item of additional) {
+      snapshots.push(makeSnapshot({
+        limitId: readField(item, "meteredFeature", "metered_feature"),
+        limitName: readField(item, "limitName", "limit_name"),
+        rateLimit: unwrap(readField(item, "rateLimit", "rate_limit")),
+        credits: null,
+        planType,
+        rateLimitReachedType: null,
+      }));
+    }
+  }
+  return snapshots;
+}
+
+function makeSnapshot({ limitId, limitName, rateLimit, credits, planType, rateLimitReachedType }) {
+  return {
+    limitId: limitId ?? null,
+    limitName: limitName ?? null,
+    primary: mapWindow(readField(rateLimit, "primary", "primaryWindow", "primary_window")),
+    secondary: mapWindow(readField(rateLimit, "secondary", "secondaryWindow", "secondary_window")),
+    credits: credits ?? null,
+    planType,
+    rateLimitReachedType,
+  };
+}
+
+function snapshotFromHeaders(headers, limitId) {
+  const headerPrefix = `x-${limitId.replaceAll("_", "-")}`;
+  return {
+    limitId,
+    limitName: readHeader(headers, `${headerPrefix}-limit-name`),
+    primary: windowFromHeaders(headers, headerPrefix, "primary"),
+    secondary: windowFromHeaders(headers, headerPrefix, "secondary"),
+    credits: limitId === "codex" ? creditsFromHeaders(headers) : null,
+    planType: null,
+    rateLimitReachedType: null,
+  };
+}
+
+function windowFromHeaders(headers, prefix, windowId) {
+  const usedPercent = readHeader(headers, `${prefix}-${windowId}-used-percent`);
+  if (usedPercent === undefined) return null;
+  return {
+    usedPercent,
+    windowDurationMins: readHeader(headers, `${prefix}-${windowId}-window-minutes`),
+    resetsAt: readHeader(headers, `${prefix}-${windowId}-reset-at`),
+  };
+}
+
+function creditsFromHeaders(headers) {
+  const hasCredits = parseHeaderBool(readHeader(headers, "x-codex-credits-has-credits"));
+  const unlimited = parseHeaderBool(readHeader(headers, "x-codex-credits-unlimited"));
+  if (hasCredits === null || unlimited === null) return null;
+  return { hasCredits, unlimited, balance: readHeader(headers, "x-codex-credits-balance") ?? null };
+}
+
+function normalizeSnapshot(snapshot) {
+  const id = readField(snapshot, "limitId", "limit_id") ?? "quota";
+  return {
+    id,
+    name: readField(snapshot, "limitName", "limit_name") ?? id,
+    windows: [
+      normalizeWindow("primary", readField(snapshot, "primary")),
+      normalizeWindow("secondary", readField(snapshot, "secondary")),
+    ].filter(Boolean),
+    rateLimitReachedType: readField(snapshot, "rateLimitReachedType", "rate_limit_reached_type") ?? null,
+  };
+}
+
+function normalizeWindow(id, window) {
+  const normalized = mapWindow(window);
+  if (!normalized) return null;
+  const label = formatWindowLabel(normalized.windowDurationMins, id);
+  return {
+    id,
+    label,
+    usedPercent: normalized.usedPercent,
+    remainingPercent: Math.max(0, 100 - normalized.usedPercent),
+    windowDurationMins: normalized.windowDurationMins,
+    resetsAt: normalized.resetsAt,
+  };
+}
+
+function mapWindow(window) {
+  const unwrapped = unwrap(window);
+  if (!unwrapped || typeof unwrapped !== "object") return null;
+  const rawUsed = readField(unwrapped, "usedPercent", "used_percent");
+  const usedPercent = Number(rawUsed);
+  if (!Number.isFinite(usedPercent)) return null;
+  const rawMinutes = readField(unwrapped, "windowDurationMins", "window_minutes", "windowDurationMinutes");
+  const rawSeconds = readField(unwrapped, "limitWindowSeconds", "limit_window_seconds");
+  return {
+    usedPercent,
+    windowDurationMins: normalizeWindowMinutes(rawMinutes, rawSeconds),
+    resetsAt: normalizeResetTime(readField(unwrapped, "resetsAt", "resets_at", "resetAt", "reset_at")),
+  };
+}
+
+function normalizeWindowMinutes(minutes, seconds) {
+  const minuteValue = Number(minutes);
+  if (Number.isFinite(minuteValue) && minuteValue > 0) return minuteValue;
+  const secondValue = Number(seconds);
+  return Number.isFinite(secondValue) && secondValue > 0 ? Math.round(secondValue / 60) : null;
+}
+
+function normalizeResetTime(value) {
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    const millis = numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+    return new Date(millis).toISOString();
+  }
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+function formatWindowLabel(minutes, fallback) {
+  if (!Number.isFinite(minutes) || minutes <= 0) return fallback;
+  if (minutes % (60 * 24 * 7) === 0) return "weekly";
+  if (minutes % 60 === 0) return `${minutes / 60}h`;
+  return `${minutes}m`;
+}
+
+function unwrap(value) {
+  return Array.isArray(value) && value.length === 1 ? value[0] : value;
+}
+
+function readField(object, ...keys) {
+  if (!object || typeof object !== "object") return undefined;
+  for (const key of keys) if (Object.hasOwn(object, key)) return object[key];
+  return undefined;
+}
+
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  if (typeof headers.entries === "function") {
+    return Object.fromEntries([...headers.entries()].map(([key, value]) => [key.toLowerCase(), String(value)]));
+  }
+  return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), String(value)]));
+}
+
+function readHeader(headers, name) {
+  const value = headers[name.toLowerCase()];
+  return value === undefined || value === "" ? undefined : value;
+}
+
+function parseHeaderBool(value) {
+  if (value === undefined) return null;
+  if (value === "1" || value.toLowerCase() === "true") return true;
+  if (value === "0" || value.toLowerCase() === "false") return false;
+  return null;
+}
+
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function firstNonEmpty(values) {
+  return values.find((value) => value !== null && value !== undefined && value !== "") ?? null;
+}

package/src/provider/quota/index.mjs

@@ -0,0 +1,46 @@
+import { fetchOpenAICodexQuota, parseOpenAICodexQuotaEvent, parseOpenAICodexQuotaHeaders } from "./codex.mjs";
+
+const quotaAdapters = new Map([
+  ["openai-codex", {
+    refresh: fetchOpenAICodexQuota,
+    observeHeaders: parseOpenAICodexQuotaHeaders,
+    observeEvent: parseOpenAICodexQuotaEvent,
+  }],
+]);
+
+export function supportsProviderQuota(providerId) {
+  return quotaAdapters.has(providerId);
+}
+
+export async function getProviderQuotaSnapshot({ providerId, model, authStorage, fetchImpl, now } = {}) {
+  const adapter = quotaAdapters.get(providerId);
+  if (!adapter) return null;
+  return adapter.refresh({ authStorage, model, fetchImpl, now });
+}
+
+export function observeProviderQuotaHeaders({ providerId, headers, model, capturedAt } = {}) {
+  const adapter = quotaAdapters.get(providerId);
+  return adapter?.observeHeaders?.(headers, { model, capturedAt }) ?? null;
+}
+
+export function observeProviderQuotaEvent({ providerId, payload, model, capturedAt } = {}) {
+  const adapter = quotaAdapters.get(providerId);
+  return adapter?.observeEvent?.(payload, { model, capturedAt }) ?? null;
+}
+
+export function createProviderQuotaService({ authStorage, fetchImpl = fetch, now = () => new Date() } = {}) {
+  return {
+    supports(providerId) {
+      return supportsProviderQuota(providerId);
+    },
+    refresh(model) {
+      return getProviderQuotaSnapshot({ providerId: model?.provider, model, authStorage, fetchImpl, now: now() });
+    },
+    observeHeaders(headers, model) {
+      return observeProviderQuotaHeaders({ providerId: model?.provider, headers, model, capturedAt: now().toISOString() });
+    },
+    observeEvent(payload, model) {
+      return observeProviderQuotaEvent({ providerId: model?.provider, payload, model, capturedAt: now().toISOString() });
+    },
+  };
+}