cc-api-statusline 0.1.0

package/dist/cc-api-statusline.js

@@ -0,0 +1,2257 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/services/env.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/services/hash.ts
+function sha256(input) {
+  if (typeof Bun !== "undefined" && typeof Bun.CryptoHasher !== "undefined") {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(input);
+    return hasher.digest("hex");
+  }
+  const crypto = __require("crypto");
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+function shortHash(input, length = 12) {
+  const fullHash = sha256(input);
+  return fullHash.slice(0, length);
+}
+
+// src/services/env.ts
+function getSettingsJsonPath() {
+  const configDir = process.env["CLAUDE_CONFIG_DIR"];
+  if (configDir) {
+    return join(configDir, "settings.json");
+  }
+  return join(homedir(), ".claude", "settings.json");
+}
+function readSettingsJsonEnv() {
+  const settingsPath = getSettingsJsonPath();
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    if (settings["env"] && typeof settings["env"] === "object") {
+      const env = settings["env"];
+      const result = {};
+      for (const [key, value] of Object.entries(env)) {
+        if (typeof value === "string") {
+          result[key] = value;
+        } else if (value !== null && value !== undefined && (typeof value === "number" || typeof value === "boolean")) {
+          result[key] = String(value);
+        }
+      }
+      return result;
+    }
+    return {};
+  } catch (error) {
+    console.warn(`Warning: Could not read settings.json: ${error}`);
+    return {};
+  }
+}
+function readCurrentEnv() {
+  const settingsEnv = readSettingsJsonEnv();
+  const getEnv = (key) => {
+    return settingsEnv[key] ?? process.env[key] ?? null;
+  };
+  const baseUrl = getEnv("ANTHROPIC_BASE_URL");
+  const authToken = getEnv("ANTHROPIC_AUTH_TOKEN");
+  const providerOverride = getEnv("CC_STATUSLINE_PROVIDER");
+  const pollIntervalRaw = getEnv("CC_STATUSLINE_POLL");
+  const tokenHash = authToken ? shortHash(authToken, 12) : null;
+  let pollIntervalOverride = null;
+  if (pollIntervalRaw) {
+    const parsed = parseInt(pollIntervalRaw, 10);
+    if (!isNaN(parsed) && parsed >= 5) {
+      pollIntervalOverride = parsed;
+    }
+  }
+  return {
+    baseUrl,
+    authToken,
+    tokenHash,
+    providerOverride,
+    pollIntervalOverride
+  };
+}
+function validateRequiredEnv(env) {
+  if (!env.baseUrl) {
+    return "Missing required environment variable: ANTHROPIC_BASE_URL";
+  }
+  if (!env.authToken) {
+    return "Missing required environment variable: ANTHROPIC_AUTH_TOKEN";
+  }
+  return null;
+}
+
+// src/services/cache.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, unlinkSync, renameSync, chmodSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/types/normalized-usage.ts
+function createEmptyNormalizedUsage(provider, billingMode, planName) {
+  return {
+    provider,
+    billingMode,
+    planName,
+    fetchedAt: new Date().toISOString(),
+    resetSemantics: "end-of-day",
+    daily: null,
+    weekly: null,
+    monthly: null,
+    balance: null,
+    resetsAt: null,
+    tokenStats: null,
+    rateLimit: null
+  };
+}
+function computeSoonestReset(usage) {
+  const times = [];
+  if (usage.daily?.resetsAt)
+    times.push(usage.daily.resetsAt);
+  if (usage.weekly?.resetsAt)
+    times.push(usage.weekly.resetsAt);
+  if (usage.monthly?.resetsAt)
+    times.push(usage.monthly.resetsAt);
+  if (times.length === 0)
+    return null;
+  times.sort();
+  return times[0] ?? null;
+}
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  display: {
+    layout: "standard",
+    displayMode: "bar",
+    barSize: "medium",
+    barStyle: "classic",
+    separator: " | ",
+    maxWidth: 80,
+    clockFormat: "24h"
+  },
+  components: {
+    daily: true,
+    weekly: true,
+    monthly: true,
+    balance: true,
+    tokens: false,
+    rateLimit: false,
+    plan: false
+  },
+  colors: {
+    auto: {
+      low: "green",
+      medium: "yellow",
+      high: "red",
+      lowThreshold: 50,
+      highThreshold: 80
+    },
+    chill: {
+      low: "cyan",
+      medium: "blue",
+      high: "magenta",
+      lowThreshold: 50,
+      highThreshold: 80
+    }
+  },
+  customProviders: {},
+  pollIntervalSeconds: 30,
+  pipedRequestTimeoutMs: 800
+};
+var BAR_SIZE_MAP = {
+  small: 4,
+  "small-medium": 6,
+  medium: 8,
+  "medium-large": 10,
+  large: 12
+};
+var BUILT_IN_BAR_STYLES = {
+  classic: { fill: "━", empty: "─" },
+  block: { fill: "█", empty: "░" },
+  shade: { fill: "▓", empty: "░" },
+  pipe: { fill: "┃", empty: "┊" },
+  dot: { fill: "●", empty: "○" },
+  braille: { fill: "⣿", empty: "⣀" },
+  square: { fill: "■", empty: "□" },
+  star: { fill: "★", empty: "☆" }
+};
+var COMPONENT_SHORT_LABELS = {
+  daily: "D",
+  weekly: "W",
+  monthly: "M",
+  balance: "B",
+  tokens: "T",
+  rateLimit: "R",
+  plan: "P"
+};
+var COMPONENT_FULL_LABELS = {
+  daily: "Daily",
+  weekly: "Weekly",
+  monthly: "Monthly",
+  balance: "Balance",
+  tokens: "Tokens",
+  rateLimit: "Rate",
+  plan: "Plan"
+};
+// src/types/cache.ts
+var CACHE_VERSION = 1;
+function isCacheEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const c = value;
+  return typeof c["version"] === "number" && typeof c["provider"] === "string" && typeof c["baseUrl"] === "string" && typeof c["tokenHash"] === "string" && typeof c["configHash"] === "string" && typeof c["data"] === "object" && c["data"] !== null && typeof c["renderedLine"] === "string" && typeof c["fetchedAt"] === "string" && typeof c["ttlSeconds"] === "number" && (c["errorState"] === null || typeof c["errorState"] === "object");
+}
+// src/services/cache.ts
+function getCacheDir() {
+  const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
+  if (override) {
+    return override;
+  }
+  return join2(homedir2(), ".claude", "cc-api-statusline");
+}
+function ensureCacheDir() {
+  const dir = getCacheDir();
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function getCachePath(baseUrl) {
+  const hash = shortHash(baseUrl, 12);
+  return join2(getCacheDir(), `cache-${hash}.json`);
+}
+function readCache(baseUrl) {
+  const path = getCachePath(baseUrl);
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(path, "utf-8");
+    const data = JSON.parse(content);
+    if (!isCacheEntry(data)) {
+      console.warn(`Invalid cache structure at ${path}`);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.warn(`Failed to read cache from ${path}: ${error}`);
+    return null;
+  }
+}
+function writeCache(baseUrl, entry) {
+  const path = getCachePath(baseUrl);
+  const tmpPath = `${path}.tmp`;
+  try {
+    ensureCacheDir();
+    const content = JSON.stringify(entry, null, 2);
+    writeFileSync(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    try {
+      chmodSync(tmpPath, 384);
+    } catch {}
+    renameSync(tmpPath, path);
+  } catch (error) {
+    console.warn(`Failed to write cache to ${path}: ${error}`);
+    try {
+      if (existsSync2(tmpPath)) {
+        unlinkSync(tmpPath);
+      }
+    } catch {}
+  }
+}
+function isCacheValid(entry, currentEnv) {
+  const fetchedAt = new Date(entry.fetchedAt).getTime();
+  const now = Date.now();
+  const age = now - fetchedAt;
+  const ttlMs = entry.ttlSeconds * 1000;
+  if (age >= ttlMs) {
+    return false;
+  }
+  if (entry.baseUrl !== currentEnv.baseUrl) {
+    return false;
+  }
+  if (entry.version !== CACHE_VERSION) {
+    return false;
+  }
+  if (entry.tokenHash !== currentEnv.tokenHash) {
+    return false;
+  }
+  return true;
+}
+function isCacheProviderValid(entry, currentProvider) {
+  return entry.provider === currentProvider;
+}
+function isCacheRenderedLineUsable(entry, currentConfigHash) {
+  return entry.configHash === currentConfigHash;
+}
+function computeConfigHash(configPath) {
+  if (!existsSync2(configPath)) {
+    return sha256("").slice(0, 12);
+  }
+  try {
+    const bytes = readFileSync2(configPath);
+    return shortHash(bytes.toString("utf-8"), 12);
+  } catch (error) {
+    console.warn(`Failed to read config for hash: ${error}`);
+    return sha256("").slice(0, 12);
+  }
+}
+var DEFAULT_POLL_INTERVAL_SECONDS = 30;
+function getEffectivePollInterval(config, envOverride) {
+  if (envOverride !== null) {
+    return Math.max(5, envOverride);
+  }
+  const fromConfig = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
+  return Math.max(5, fromConfig);
+}
+
+// src/services/config.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function getConfigDir() {
+  return join3(homedir3(), ".claude", "cc-api-statusline");
+}
+function getConfigPath(customPath) {
+  if (customPath) {
+    return customPath;
+  }
+  return join3(getConfigDir(), "config.json");
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== undefined) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function validateConfig(config) {
+  if (config.display.maxWidth < 20) {
+    console.warn("Warning: display.maxWidth < 20, clamping to 20");
+    config.display.maxWidth = 20;
+  }
+  if (config.display.maxWidth > 100) {
+    console.warn("Warning: display.maxWidth > 100, clamping to 100");
+    config.display.maxWidth = 100;
+  }
+  if (config.pollIntervalSeconds !== undefined && config.pollIntervalSeconds < 5) {
+    console.warn("Warning: pollIntervalSeconds < 5, clamping to 5");
+    config.pollIntervalSeconds = 5;
+  }
+  if (config.pipedRequestTimeoutMs !== undefined && config.pipedRequestTimeoutMs < 100) {
+    console.warn("Warning: pipedRequestTimeoutMs < 100, clamping to 100");
+    config.pipedRequestTimeoutMs = 100;
+  }
+  return config;
+}
+function loadConfig(configPath) {
+  const path = getConfigPath(configPath);
+  if (!existsSync3(path)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync3(path, "utf-8");
+    const userConfig = JSON.parse(content);
+    const merged = deepMerge(DEFAULT_CONFIG, userConfig);
+    return validateConfig(merged);
+  } catch (error) {
+    console.warn(`Warning: Could not load config from ${path}: ${error}`);
+    console.warn("Using default configuration");
+    return DEFAULT_CONFIG;
+  }
+}
+
+// src/providers/http.ts
+class HttpError extends Error {
+  statusCode;
+  response;
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "HttpError";
+  }
+}
+
+class TimeoutError extends Error {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+class RedirectError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedirectError";
+  }
+}
+
+class ResponseTooLargeError extends Error {
+  constructor(message = "Response body exceeds 1MB limit") {
+    super(message);
+    this.name = "ResponseTooLargeError";
+  }
+}
+function isSecureUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "https:") {
+      return true;
+    }
+    if (parsed.protocol === "http:") {
+      const hostname = parsed.hostname.toLowerCase();
+      if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1") {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getHostname(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+async function readBodyWithLimit(response) {
+  const MAX_SIZE = 1024 * 1024;
+  let bytesRead = 0;
+  const chunks = [];
+  if (!response.body) {
+    return "";
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  try {
+    while (true) {
+      const result2 = await reader.read();
+      if (result2.done)
+        break;
+      if (result2.value) {
+        const chunk = result2.value;
+        bytesRead += chunk.length;
+        if (bytesRead > MAX_SIZE) {
+          await reader.cancel();
+          throw new ResponseTooLargeError(`Response body exceeds 1MB limit (read ${bytesRead} bytes)`);
+        }
+        chunks.push(chunk);
+      }
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return decoder.decode(result);
+  } catch (error) {
+    if (error instanceof ResponseTooLargeError) {
+      throw error;
+    }
+    throw new HttpError(`Failed to read response body: ${error}`);
+  }
+}
+async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
+  if (!isSecureUrl(url)) {
+    throw new HttpError(`Insecure URL rejected (must be HTTPS or localhost): ${url}`);
+  }
+  const originalHostname = getHostname(url);
+  if (!originalHostname) {
+    throw new HttpError(`Invalid URL: ${url}`);
+  }
+  const signal = AbortSignal.timeout(timeoutMs);
+  const fetchOptions = {
+    ...options,
+    redirect: "manual",
+    signal
+  };
+  if (userAgent) {
+    const headers = new Headers(options.headers);
+    headers.set("User-Agent", userAgent);
+    fetchOptions.headers = headers;
+  }
+  try {
+    const response = await fetch(url, fetchOptions);
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("Location");
+      if (location) {
+        const redirectHostname = getHostname(location);
+        if (redirectHostname && redirectHostname !== originalHostname) {
+          throw new RedirectError(`Cross-domain redirect blocked: ${originalHostname} → ${redirectHostname}`);
+        }
+        throw new RedirectError(`Redirect detected to: ${location}`);
+      }
+      throw new RedirectError("Redirect detected but Location header missing");
+    }
+    if (!response.ok) {
+      let errorContext = response.statusText;
+      try {
+        const errorBody = await readBodyWithLimit(response);
+        if (errorBody)
+          errorContext = errorBody.slice(0, 200);
+      } catch {}
+      throw new HttpError(`HTTP ${response.status}: ${errorContext}`, response.status, response);
+    }
+    return await readBodyWithLimit(response);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError" || error.name === "TimeoutError") {
+        throw new TimeoutError(`Request timed out after ${timeoutMs}ms`);
+      }
+    }
+    if (error instanceof HttpError || error instanceof TimeoutError || error instanceof RedirectError || error instanceof ResponseTooLargeError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("timed out")) {
+      throw new TimeoutError(`Request timed out after ${timeoutMs}ms`);
+    }
+    throw new HttpError(`Network error: ${error}`);
+  }
+}
+
+// src/services/user-agent.ts
+import { execSync } from "child_process";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+
+// src/services/logger.ts
+import { appendFileSync, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { join as join4, dirname } from "path";
+import { homedir as homedir4 } from "os";
+
+class Logger {
+  enabled;
+  logPath;
+  constructor() {
+    this.enabled = !!(process.env["DEBUG"] || process.env["CC_STATUSLINE_DEBUG"]);
+    const logDir = process.env["CC_API_STATUSLINE_LOG_DIR"] || join4(homedir4(), ".claude", "cc-api-statusline");
+    this.logPath = join4(logDir, "debug.log");
+    if (this.enabled) {
+      this.ensureLogDir();
+    }
+  }
+  ensureLogDir() {
+    try {
+      const dir = dirname(this.logPath);
+      if (!existsSync4(dir)) {
+        mkdirSync3(dir, { recursive: true, mode: 448 });
+      }
+    } catch {
+      this.enabled = false;
+    }
+  }
+  format(level, message, data) {
+    const timestamp = new Date().toISOString();
+    const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+    return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}
+`;
+  }
+  write(level, message, data) {
+    if (!this.enabled) {
+      return;
+    }
+    try {
+      const entry = this.format(level, message, data);
+      appendFileSync(this.logPath, entry, { encoding: "utf-8" });
+    } catch {}
+  }
+  debug(message, data) {
+    this.write("debug", message, data);
+  }
+  info(message, data) {
+    this.write("info", message, data);
+  }
+  warn(message, data) {
+    this.write("warn", message, data);
+  }
+  error(message, data) {
+    this.write("error", message, data);
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+}
+var logger = new Logger;
+
+// src/services/user-agent.ts
+var FALLBACK_UA = "claude-cli/2.1.56 (external, cli)";
+function resolveUserAgent(config) {
+  if (!config) {
+    return null;
+  }
+  if (typeof config === "string") {
+    return config || null;
+  }
+  return detectClaudeCodeUA();
+}
+function detectClaudeCodeUA() {
+  logger.debug("UA spoofing enabled, attempting detection");
+  const version = detectClaudeVersion();
+  if (version) {
+    const ua = `claude-cli/${version} (external, cli)`;
+    logger.debug(`Detected Claude Code version: ${version}`);
+    return ua;
+  }
+  logger.debug(`Detection failed, using fallback: ${FALLBACK_UA}`);
+  return FALLBACK_UA;
+}
+function detectClaudeVersion() {
+  try {
+    if (!process.env["CLAUDECODE"]) {
+      return null;
+    }
+    const claudePath = join5(homedir5(), ".claude", "bin", "claude");
+    const result = execSync(`"${claudePath}" --version`, {
+      encoding: "utf-8",
+      timeout: 1000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const match = result.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/sub2api.ts
+function computeNextMidnightUTC() {
+  const now = new Date;
+  const tomorrow = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, 0, 0, 0, 0));
+  return tomorrow.toISOString();
+}
+function computeNextMondayUTC() {
+  const now = new Date;
+  const dayOfWeek = now.getUTCDay();
+  const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
+  const nextMonday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0, 0));
+  return nextMonday.toISOString();
+}
+function computeFirstOfNextMonthUTC() {
+  const now = new Date;
+  const nextMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1, 0, 0, 0, 0));
+  return nextMonth.toISOString();
+}
+function mapPeriodTokens(data) {
+  if (!data)
+    return null;
+  return {
+    requests: data.requests ?? 0,
+    inputTokens: data.input_tokens ?? 0,
+    outputTokens: data.output_tokens ?? 0,
+    cacheCreationTokens: data.cache_creation_tokens ?? 0,
+    cacheReadTokens: data.cache_read_tokens ?? 0,
+    totalTokens: data.total_tokens ?? 0,
+    cost: data.cost ?? 0
+  };
+}
+function createQuotaWindow(used, limit, resetsAt) {
+  if (used === undefined)
+    return null;
+  const actualLimit = limit === null || limit === undefined ? null : limit;
+  let remaining = null;
+  if (actualLimit !== null) {
+    remaining = Math.max(0, actualLimit - used);
+  }
+  return {
+    used,
+    limit: actualLimit,
+    remaining,
+    resetsAt
+  };
+}
+async function fetchSub2api(baseUrl, token, config, timeoutMs = 5000) {
+  const url = `${baseUrl}/v1/usage`;
+  const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
+  if (resolvedUA) {
+    logger.debug(`Using User-Agent: ${resolvedUA}`);
+  }
+  try {
+    const responseText = await secureFetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json"
+      }
+    }, timeoutMs, resolvedUA);
+    const data = JSON.parse(responseText);
+    const hasSubscription = !!data.subscription;
+    const billingMode = hasSubscription ? "subscription" : "balance";
+    const result = {
+      provider: "sub2api",
+      billingMode,
+      planName: data.planName ?? "Unknown",
+      fetchedAt: new Date().toISOString(),
+      resetSemantics: "end-of-day",
+      daily: null,
+      weekly: null,
+      monthly: null,
+      balance: null,
+      resetsAt: null,
+      tokenStats: null,
+      rateLimit: null
+    };
+    if (billingMode === "balance") {
+      const remaining = data.remaining ?? 0;
+      if (remaining === -1) {
+        result.balance = {
+          remaining: -1,
+          initial: null,
+          unit: data.unit ?? "USD"
+        };
+      } else {
+        result.balance = {
+          remaining,
+          initial: null,
+          unit: data.unit ?? "USD"
+        };
+      }
+    } else {
+      const sub = data.subscription;
+      if (!sub) {
+        throw new Error("Subscription mode but no subscription object in response");
+      }
+      result.daily = createQuotaWindow(sub.daily_usage_usd, sub.daily_limit_usd, computeNextMidnightUTC());
+      result.weekly = createQuotaWindow(sub.weekly_usage_usd, sub.weekly_limit_usd, computeNextMondayUTC());
+      result.monthly = createQuotaWindow(sub.monthly_usage_usd, sub.monthly_limit_usd, computeFirstOfNextMonthUTC());
+      result.resetsAt = computeSoonestReset(result);
+    }
+    if (data.usage) {
+      result.tokenStats = {
+        today: mapPeriodTokens(data.usage.today),
+        total: mapPeriodTokens(data.usage.total),
+        rpm: data.usage.rpm ?? null,
+        tpm: data.usage.tpm ?? null
+      };
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof HttpError && error.statusCode === 429) {
+      return {
+        provider: "sub2api",
+        billingMode: "subscription",
+        planName: "Quota Exhausted",
+        fetchedAt: new Date().toISOString(),
+        resetSemantics: "end-of-day",
+        daily: {
+          used: 0,
+          limit: 0,
+          remaining: 0,
+          resetsAt: computeNextMidnightUTC()
+        },
+        weekly: null,
+        monthly: null,
+        balance: null,
+        resetsAt: computeNextMidnightUTC(),
+        tokenStats: null,
+        rateLimit: null
+      };
+    }
+    throw error;
+  }
+}
+
+// src/providers/claude-relay-service.ts
+function computeWeeklyResetTime(resetDay, resetHour) {
+  const now = new Date;
+  const currentDay = now.getUTCDay();
+  const currentHour = now.getUTCHours();
+  let daysUntilReset = resetDay - currentDay;
+  if (daysUntilReset < 0 || daysUntilReset === 0 && currentHour >= resetHour) {
+    daysUntilReset += 7;
+  }
+  const resetDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilReset, resetHour, 0, 0, 0));
+  return resetDate.toISOString();
+}
+function createQuotaWindow2(used, limit, resetsAt) {
+  if (used === undefined)
+    return null;
+  const actualLimit = limit && limit > 0 ? limit : null;
+  let remaining = null;
+  if (actualLimit !== null) {
+    remaining = Math.max(0, actualLimit - used);
+  }
+  return {
+    used,
+    limit: actualLimit,
+    remaining,
+    resetsAt
+  };
+}
+async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = 5000) {
+  const url = `${baseUrl}/apiStats/api/user-stats`;
+  const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
+  if (resolvedUA) {
+    logger.debug(`Using User-Agent: ${resolvedUA}`);
+  }
+  const responseText = await secureFetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({ apiKey: token })
+  }, timeoutMs, resolvedUA);
+  const response = JSON.parse(responseText);
+  if (!response.success) {
+    throw new HttpError("Relay API returned success: false");
+  }
+  const data = response.data;
+  const limits = data.limits;
+  const result = {
+    provider: "claude-relay-service",
+    billingMode: "subscription",
+    planName: data.name ?? "API Key",
+    fetchedAt: new Date().toISOString(),
+    resetSemantics: "rolling-window",
+    daily: null,
+    weekly: null,
+    monthly: null,
+    balance: null,
+    resetsAt: null,
+    tokenStats: null,
+    rateLimit: null
+  };
+  result.daily = createQuotaWindow2(limits.currentDailyCost, limits.dailyCostLimit, null);
+  if (limits.weeklyResetDay !== undefined && limits.weeklyResetHour !== undefined) {
+    const weeklyResetsAt = computeWeeklyResetTime(limits.weeklyResetDay, limits.weeklyResetHour);
+    result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, weeklyResetsAt);
+  } else {
+    result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, null);
+  }
+  result.monthly = null;
+  if (limits.windowEndTime) {
+    result.resetsAt = new Date(limits.windowEndTime).toISOString();
+  }
+  if (data.usage?.total) {
+    const total = data.usage.total;
+    result.tokenStats = {
+      today: null,
+      total: {
+        requests: total.requests ?? 0,
+        inputTokens: total.inputTokens ?? 0,
+        outputTokens: total.outputTokens ?? 0,
+        cacheCreationTokens: total.cacheCreateTokens ?? 0,
+        cacheReadTokens: total.cacheReadTokens ?? 0,
+        totalTokens: total.tokens ?? (total.inputTokens ?? 0) + (total.outputTokens ?? 0),
+        cost: total.cost ?? 0
+      },
+      rpm: null,
+      tpm: null
+    };
+  }
+  if (limits.rateLimitWindow !== undefined) {
+    result.rateLimit = {
+      windowSeconds: limits.rateLimitWindow * 60,
+      requestsUsed: limits.currentWindowRequests ?? 0,
+      requestsLimit: limits.rateLimitRequests && limits.rateLimitRequests > 0 ? limits.rateLimitRequests : null,
+      costUsed: limits.currentWindowCost ?? 0,
+      costLimit: limits.rateLimitCost && limits.rateLimitCost > 0 ? limits.rateLimitCost : null,
+      remainingSeconds: limits.windowRemainingSeconds ?? 0
+    };
+  }
+  return result;
+}
+
+// src/providers/custom.ts
+function resolveJsonPath(data, path) {
+  if (!path.startsWith("$.")) {
+    return path;
+  }
+  const parts = path.slice(2).split(/\.|\[|\]/).filter((p) => p.length > 0);
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === undefined) {
+      return null;
+    }
+    if (typeof current !== "object") {
+      return null;
+    }
+    const index = parseInt(part, 10);
+    if (!isNaN(index) && Array.isArray(current)) {
+      current = current[index];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
+function extractValue(data, mapping, defaultValue = null) {
+  if (!mapping)
+    return defaultValue;
+  const resolved = resolveJsonPath(data, mapping);
+  return resolved ?? defaultValue;
+}
+function extractNumber(data, mapping) {
+  const value = extractValue(data, mapping);
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    return isNaN(parsed) ? null : parsed;
+  }
+  return null;
+}
+function extractString(data, mapping, defaultValue = "") {
+  const value = extractValue(data, mapping, defaultValue);
+  if (typeof value === "string")
+    return value;
+  return String(value);
+}
+function validateCustomProvider(providerConfig) {
+  if (!providerConfig.id)
+    return "Custom provider missing required field: id";
+  if (!providerConfig.endpoint)
+    return "Custom provider missing required field: endpoint";
+  if (!providerConfig.method)
+    return "Custom provider missing required field: method";
+  if (!providerConfig.auth)
+    return "Custom provider missing required field: auth";
+  if (!providerConfig.responseMapping)
+    return "Custom provider missing required field: responseMapping";
+  if (!providerConfig.endpoint.startsWith("/")) {
+    return "Custom provider endpoint must start with /";
+  }
+  if (!providerConfig.responseMapping.billingMode) {
+    return "Custom provider responseMapping must include billingMode";
+  }
+  if (providerConfig.auth.type === "header" && !providerConfig.auth.header) {
+    return 'Custom provider auth.type="header" requires auth.header';
+  }
+  if (providerConfig.auth.type === "body" && !providerConfig.auth.bodyField) {
+    return 'Custom provider auth.type="body" requires auth.bodyField';
+  }
+  if (providerConfig.urlPatterns && !Array.isArray(providerConfig.urlPatterns)) {
+    return "Custom provider urlPatterns must be an array";
+  }
+  return null;
+}
+async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs = 5000) {
+  const validationError = validateCustomProvider(providerConfig);
+  if (validationError) {
+    throw new Error(`Invalid custom provider providerConfig: ${validationError}`);
+  }
+  const url = `${baseUrl}${providerConfig.endpoint}`;
+  const headers = {
+    Accept: "application/json"
+  };
+  if (providerConfig.contentType) {
+    headers["Content-Type"] = providerConfig.contentType;
+  }
+  if (providerConfig.auth.type === "header" && providerConfig.auth.header) {
+    const prefix = providerConfig.auth.prefix ?? "";
+    headers[providerConfig.auth.header] = `${prefix}${token}`;
+  }
+  let body;
+  if (providerConfig.method === "POST") {
+    if (providerConfig.auth.type === "body" && providerConfig.auth.bodyField) {
+      const bodyObj = { ...providerConfig.requestBody };
+      bodyObj[providerConfig.auth.bodyField] = token;
+      body = JSON.stringify(bodyObj);
+    } else if (providerConfig.requestBody) {
+      body = JSON.stringify(providerConfig.requestBody);
+    }
+  }
+  const providerUA = providerConfig.spoofClaudeCodeUA;
+  const globalUA = appConfig.spoofClaudeCodeUA;
+  const effectiveUA = providerUA !== undefined ? providerUA : globalUA;
+  const resolvedUA = resolveUserAgent(effectiveUA);
+  if (resolvedUA) {
+    logger.debug(`Using User-Agent for ${providerConfig.id}: ${resolvedUA}`);
+  }
+  const responseText = await secureFetch(url, {
+    method: providerConfig.method,
+    headers,
+    body
+  }, timeoutMs, resolvedUA);
+  const responseData = JSON.parse(responseText);
+  const mapping = providerConfig.responseMapping;
+  const billingModeStr = extractString(responseData, mapping.billingMode, "subscription");
+  const billingMode = billingModeStr === "balance" ? "balance" : "subscription";
+  const planName = extractString(responseData, mapping.planName, providerConfig.displayName ?? providerConfig.id);
+  const result = createEmptyNormalizedUsage(providerConfig.id, billingMode, planName);
+  result.resetSemantics = billingMode === "balance" ? "expiry" : "end-of-day";
+  if (mapping["balance.remaining"]) {
+    const remaining = extractNumber(responseData, mapping["balance.remaining"]);
+    if (remaining !== null) {
+      result.balance = {
+        remaining,
+        initial: extractNumber(responseData, mapping["balance.initial"]),
+        unit: extractString(responseData, mapping["balance.unit"], "USD")
+      };
+    }
+  }
+  const dailyUsed = extractNumber(responseData, mapping["daily.used"]);
+  const dailyLimitRaw = extractNumber(responseData, mapping["daily.limit"]);
+  const dailyLimit = dailyLimitRaw === 0 ? null : dailyLimitRaw;
+  if (dailyUsed !== null) {
+    result.daily = {
+      used: dailyUsed,
+      limit: dailyLimit,
+      remaining: dailyLimit !== null ? Math.max(0, dailyLimit - dailyUsed) : null,
+      resetsAt: extractString(responseData, mapping["daily.resetsAt"], "") || null
+    };
+  }
+  const weeklyUsed = extractNumber(responseData, mapping["weekly.used"]);
+  const weeklyLimitRaw = extractNumber(responseData, mapping["weekly.limit"]);
+  const weeklyLimit = weeklyLimitRaw === 0 ? null : weeklyLimitRaw;
+  if (weeklyUsed !== null) {
+    result.weekly = {
+      used: weeklyUsed,
+      limit: weeklyLimit,
+      remaining: weeklyLimit !== null ? Math.max(0, weeklyLimit - weeklyUsed) : null,
+      resetsAt: extractString(responseData, mapping["weekly.resetsAt"], "") || null
+    };
+  }
+  const monthlyUsed = extractNumber(responseData, mapping["monthly.used"]);
+  const monthlyLimitRaw = extractNumber(responseData, mapping["monthly.limit"]);
+  const monthlyLimit = monthlyLimitRaw === 0 ? null : monthlyLimitRaw;
+  if (monthlyUsed !== null) {
+    result.monthly = {
+      used: monthlyUsed,
+      limit: monthlyLimit,
+      remaining: monthlyLimit !== null ? Math.max(0, monthlyLimit - monthlyUsed) : null,
+      resetsAt: extractString(responseData, mapping["monthly.resetsAt"], "") || null
+    };
+  }
+  if (mapping["tokenStats.today.requests"]) {
+    const todayRequests = extractNumber(responseData, mapping["tokenStats.today.requests"]);
+    if (todayRequests !== null) {
+      result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
+      result.tokenStats.today = {
+        requests: todayRequests,
+        inputTokens: extractNumber(responseData, mapping["tokenStats.today.inputTokens"]) ?? 0,
+        outputTokens: extractNumber(responseData, mapping["tokenStats.today.outputTokens"]) ?? 0,
+        cacheCreationTokens: extractNumber(responseData, mapping["tokenStats.today.cacheCreationTokens"]) ?? 0,
+        cacheReadTokens: extractNumber(responseData, mapping["tokenStats.today.cacheReadTokens"]) ?? 0,
+        totalTokens: extractNumber(responseData, mapping["tokenStats.today.totalTokens"]) ?? 0,
+        cost: extractNumber(responseData, mapping["tokenStats.today.cost"]) ?? 0
+      };
+    }
+  }
+  if (mapping["tokenStats.total.requests"]) {
+    const totalRequests = extractNumber(responseData, mapping["tokenStats.total.requests"]);
+    if (totalRequests !== null) {
+      result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
+      result.tokenStats.total = {
+        requests: totalRequests,
+        inputTokens: extractNumber(responseData, mapping["tokenStats.total.inputTokens"]) ?? 0,
+        outputTokens: extractNumber(responseData, mapping["tokenStats.total.outputTokens"]) ?? 0,
+        cacheCreationTokens: extractNumber(responseData, mapping["tokenStats.total.cacheCreationTokens"]) ?? 0,
+        cacheReadTokens: extractNumber(responseData, mapping["tokenStats.total.cacheReadTokens"]) ?? 0,
+        totalTokens: extractNumber(responseData, mapping["tokenStats.total.totalTokens"]) ?? 0,
+        cost: extractNumber(responseData, mapping["tokenStats.total.cost"]) ?? 0
+      };
+    }
+  }
+  if (mapping["tokenStats.rpm"]) {
+    result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
+    result.tokenStats.rpm = extractNumber(responseData, mapping["tokenStats.rpm"]);
+  }
+  if (mapping["tokenStats.tpm"]) {
+    result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
+    result.tokenStats.tpm = extractNumber(responseData, mapping["tokenStats.tpm"]);
+  }
+  if (mapping["rateLimit.windowSeconds"]) {
+    const windowSeconds = extractNumber(responseData, mapping["rateLimit.windowSeconds"]);
+    if (windowSeconds !== null) {
+      result.rateLimit = {
+        windowSeconds,
+        requestsUsed: extractNumber(responseData, mapping["rateLimit.requestsUsed"]) ?? 0,
+        requestsLimit: extractNumber(responseData, mapping["rateLimit.requestsLimit"]),
+        costUsed: extractNumber(responseData, mapping["rateLimit.costUsed"]) ?? 0,
+        costLimit: extractNumber(responseData, mapping["rateLimit.costLimit"]),
+        remainingSeconds: extractNumber(responseData, mapping["rateLimit.remainingSeconds"]) ?? 0
+      };
+    }
+  }
+  if (result.daily?.resetsAt || result.weekly?.resetsAt || result.monthly?.resetsAt) {
+    const times = [];
+    if (result.daily?.resetsAt)
+      times.push(result.daily.resetsAt);
+    if (result.weekly?.resetsAt)
+      times.push(result.weekly.resetsAt);
+    if (result.monthly?.resetsAt)
+      times.push(result.monthly.resetsAt);
+    times.sort();
+    result.resetsAt = times[0] ?? null;
+  }
+  return result;
+}
+
+// src/providers/autodetect.ts
+var detectionCache = new Map;
+function detectProvider(baseUrl, customProviders = {}) {
+  const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
+  for (const [providerId, config] of Object.entries(customProviders)) {
+    if (config.urlPatterns && config.urlPatterns.length > 0) {
+      for (const pattern of config.urlPatterns) {
+        const normalizedPattern = pattern.toLowerCase();
+        if (normalizedUrl.includes(normalizedPattern)) {
+          return providerId;
+        }
+      }
+    }
+  }
+  if (normalizedUrl.includes("/apistats") || normalizedUrl.includes("relay") || normalizedUrl.includes("/api/user-stats")) {
+    return "claude-relay-service";
+  }
+  return "sub2api";
+}
+function resolveProvider(baseUrl, providerOverride, customProviders = {}) {
+  if (providerOverride) {
+    return providerOverride;
+  }
+  const cached = detectionCache.get(baseUrl);
+  if (cached) {
+    return cached.provider;
+  }
+  const provider = detectProvider(baseUrl, customProviders);
+  detectionCache.set(baseUrl, {
+    provider,
+    detectedAt: new Date().toISOString()
+  });
+  return provider;
+}
+
+// src/providers/index.ts
+var BUILT_IN_ADAPTERS = {
+  sub2api: {
+    fetch: fetchSub2api
+  },
+  "claude-relay-service": {
+    fetch: fetchClaudeRelayService
+  }
+};
+function getProvider(providerId, customProviders = {}) {
+  if (BUILT_IN_ADAPTERS[providerId]) {
+    return BUILT_IN_ADAPTERS[providerId];
+  }
+  const customConfig = customProviders[providerId];
+  if (customConfig) {
+    return {
+      fetch: (baseUrl, token, config, timeoutMs) => fetchCustom(baseUrl, token, config, customConfig, timeoutMs)
+    };
+  }
+  return null;
+}
+
+// src/renderer/colors.ts
+var ANSI_COLORS = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  "bright-black": "\x1B[90m",
+  "bright-red": "\x1B[91m",
+  "bright-green": "\x1B[92m",
+  "bright-yellow": "\x1B[93m",
+  "bright-blue": "\x1B[94m",
+  "bright-magenta": "\x1B[95m",
+  "bright-cyan": "\x1B[96m",
+  "bright-white": "\x1B[97m",
+  gray: "\x1B[90m",
+  grey: "\x1B[90m"
+};
+var ANSI_RESET = "\x1B[0m";
+var ANSI_DIM = "\x1B[2m";
+function ansiColor(text, color) {
+  if (!color)
+    return text;
+  if (ANSI_COLORS[color.toLowerCase()]) {
+    return `${ANSI_COLORS[color.toLowerCase()]}${text}${ANSI_RESET}`;
+  }
+  if (color.startsWith("#")) {
+    const rgb = hexToRgb(color);
+    if (rgb) {
+      return `\x1B[38;2;${rgb.r};${rgb.g};${rgb.b}m${text}${ANSI_RESET}`;
+    }
+  }
+  return text;
+}
+function hexToRgb(hex) {
+  const cleanHex = hex.replace(/^#/, "");
+  if (cleanHex.length === 3) {
+    const [r, g, b] = cleanHex.split("").map((c) => parseInt(c + c, 16));
+    if (isNaN(r) || isNaN(g) || isNaN(b))
+      return null;
+    return { r, g, b };
+  }
+  if (cleanHex.length === 6) {
+    const r = parseInt(cleanHex.slice(0, 2), 16);
+    const g = parseInt(cleanHex.slice(2, 4), 16);
+    const b = parseInt(cleanHex.slice(4, 6), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b))
+      return null;
+    return { r, g, b };
+  }
+  return null;
+}
+function dimText(text) {
+  return `${ANSI_DIM}${text}${ANSI_RESET}`;
+}
+function resolveColor(colorName, usagePercent, config) {
+  const effectiveColor = colorName ?? "auto";
+  if (effectiveColor.startsWith("#") || ANSI_COLORS[effectiveColor.toLowerCase()]) {
+    return effectiveColor;
+  }
+  const alias = config.colors?.[effectiveColor];
+  if (!alias) {
+    const autoAlias = config.colors?.auto;
+    if (typeof autoAlias === "string") {
+      return autoAlias;
+    }
+    return resolveColorAlias(autoAlias, usagePercent);
+  }
+  if (typeof alias === "string") {
+    return alias;
+  }
+  return resolveColorAlias(alias, usagePercent);
+}
+function resolveColorAlias(alias, usagePercent) {
+  if (!alias)
+    return null;
+  if (usagePercent === null) {
+    return alias.low;
+  }
+  if (usagePercent < alias.lowThreshold) {
+    return alias.low;
+  } else if (usagePercent < alias.highThreshold) {
+    return alias.medium;
+  } else {
+    return alias.high;
+  }
+}
+
+// src/renderer/error.ts
+function renderError(errorState, mode, provider, message, cacheAge) {
+  const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
+  if (isTransition) {
+    return renderTransitionState(errorState);
+  }
+  if (mode === "without-cache") {
+    return renderStandaloneError(errorState, provider, message);
+  }
+  return renderErrorIndicator(errorState, cacheAge);
+}
+function renderTransitionState(errorState) {
+  const icon = "⟳";
+  let message;
+  switch (errorState) {
+    case "switching-provider":
+      message = "Switching provider...";
+      break;
+    case "new-credentials":
+      message = "New credentials, refreshing...";
+      break;
+    case "new-endpoint":
+      message = "New endpoint, refreshing...";
+      break;
+    case "auth-error-waiting":
+      return `${ansiColor("⚠", "yellow")} Auth error ${dimText(`${icon} Waiting for new credentials...`)}`;
+    default:
+      message = "Transitioning...";
+  }
+  return dimText(`${icon} ${message}`);
+}
+function renderStandaloneError(errorState, provider, message) {
+  const warningIcon = ansiColor("⚠", "yellow");
+  switch (errorState) {
+    case "auth-error":
+      return `${warningIcon} Auth error`;
+    case "rate-limited":
+      return `${warningIcon} Rate limited`;
+    case "provider-unknown":
+      return `${warningIcon} Unknown provider`;
+    case "missing-env":
+      return `${warningIcon} Set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN`;
+    case "network-error":
+    case "server-error":
+    case "parse-error":
+      if (provider && message) {
+        return `${warningIcon} ${provider}: ${message}`;
+      } else if (provider) {
+        return `${warningIcon} ${provider}: ${getDefaultMessage(errorState)}`;
+      } else {
+        return `${warningIcon} ${getDefaultMessage(errorState)}`;
+      }
+    default:
+      return `${warningIcon} Error`;
+  }
+}
+function renderErrorIndicator(errorState, cacheAge) {
+  switch (errorState) {
+    case "network-error":
+      return renderStalenessIndicator("[offline]", cacheAge, false);
+    case "server-error":
+      return renderStalenessIndicator("[stale]", cacheAge, true);
+    case "parse-error":
+      return "[parse error]";
+    case "rate-limited":
+      return "[rate limited]";
+    default:
+      return "[error]";
+  }
+}
+function renderStalenessIndicator(label, cacheAge, showAge = true) {
+  if (cacheAge === undefined) {
+    return dimText(label);
+  }
+  const stalenessLevel = getStalenessLevel(cacheAge);
+  let text = label;
+  if (showAge && cacheAge >= 5) {
+    text = `[stale ${cacheAge}m]`;
+  }
+  switch (stalenessLevel) {
+    case "fresh":
+      return dimText(label);
+    case "stale":
+      return dimText(text);
+    case "very-stale":
+      return ansiColor(text, "yellow");
+  }
+}
+function getStalenessLevel(ageMinutes) {
+  if (ageMinutes < 5) {
+    return "fresh";
+  } else if (ageMinutes <= 30) {
+    return "stale";
+  } else {
+    return "very-stale";
+  }
+}
+function getDefaultMessage(errorState) {
+  switch (errorState) {
+    case "network-error":
+      return "connection refused";
+    case "server-error":
+      return "server error";
+    case "parse-error":
+      return "invalid response";
+    case "auth-error":
+      return "authentication failed";
+    case "rate-limited":
+      return "rate limited";
+    default:
+      return "error";
+  }
+}
+
+// src/renderer/bar.ts
+function renderBar(percent, size, style, fillColor, emptyColor) {
+  if (percent === -1) {
+    return "";
+  }
+  const effectivePercent = percent ?? 0;
+  const clampedPercent = Math.max(0, Math.min(100, effectivePercent));
+  const barWidth = BAR_SIZE_MAP[size];
+  const barChars = resolveBarStyle(style);
+  if (typeof style === "string" && style === "braille") {
+    return renderBrailleBar(clampedPercent, barWidth, fillColor, emptyColor);
+  }
+  const filledCount = Math.round(clampedPercent / 100 * barWidth);
+  const emptyCount = barWidth - filledCount;
+  const filledPart = barChars.fill.repeat(filledCount);
+  const coloredFilled = fillColor ? ansiColor(filledPart, fillColor) : filledPart;
+  const emptyPart = barChars.empty.repeat(emptyCount);
+  const coloredEmpty = emptyColor ? ansiColor(emptyPart, emptyColor) : dimText(emptyPart);
+  return coloredFilled + coloredEmpty;
+}
+function resolveBarStyle(style) {
+  if (typeof style === "string") {
+    return BUILT_IN_BAR_STYLES[style] ?? BUILT_IN_BAR_STYLES.classic;
+  }
+  return style;
+}
+function renderBrailleBar(percent, barWidth, fillColor, emptyColor) {
+  const brailleChars = ["⣀", "⣄", "⣆", "⣇", "⣧", "⣷", "⣿"];
+  const emptyChar = "⣀";
+  const fullChar = "⣿";
+  const exactFill = percent / 100 * barWidth;
+  const fullCells = Math.floor(exactFill);
+  const remainder = exactFill - fullCells;
+  let bar = "";
+  for (let i = 0;i < fullCells; i++) {
+    bar += fullChar;
+  }
+  if (fullCells < barWidth && remainder > 0) {
+    const gradientIndex = Math.floor(remainder * (brailleChars.length - 1));
+    bar += brailleChars[gradientIndex] ?? emptyChar;
+  }
+  const emptyCells = barWidth - fullCells - (remainder > 0 ? 1 : 0);
+  for (let i = 0;i < emptyCells; i++) {
+    bar += emptyChar;
+  }
+  const filledPart = bar.slice(0, fullCells + (remainder > 0 ? 1 : 0));
+  const emptyPart = bar.slice(fullCells + (remainder > 0 ? 1 : 0));
+  const coloredFilled = fillColor ? ansiColor(filledPart, fillColor) : filledPart;
+  const coloredEmpty = emptyColor ? ansiColor(emptyPart, emptyColor) : dimText(emptyPart);
+  return coloredFilled + coloredEmpty;
+}
+
+// src/renderer/countdown.ts
+function renderCountdown(resetsAt, config, clockFormat) {
+  if (!resetsAt) {
+    return "";
+  }
+  const format = config.format ?? "auto";
+  const divider = config.divider ?? " · ";
+  const prefix = config.prefix ?? "";
+  const resetDate = new Date(resetsAt);
+  if (isNaN(resetDate.getTime())) {
+    return "";
+  }
+  const now = new Date;
+  const remainingMs = resetDate.getTime() - now.getTime();
+  if (remainingMs < 0) {
+    return `${divider}${prefix}now`;
+  }
+  let timeStr;
+  if (format === "auto") {
+    if (remainingMs < 60000) {
+      timeStr = "now";
+    } else if (remainingMs <= 86400000) {
+      timeStr = formatDuration(remainingMs);
+    } else {
+      timeStr = formatWallClock(resetDate, clockFormat);
+    }
+  } else if (format === "duration") {
+    if (remainingMs < 60000) {
+      timeStr = "now";
+    } else {
+      timeStr = formatDuration(remainingMs);
+    }
+  } else {
+    timeStr = formatWallClock(resetDate, clockFormat);
+  }
+  return `${divider}${prefix}${timeStr}`;
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days >= 1) {
+    const remainingHours = hours % 24;
+    return `${days}d ${remainingHours}h`;
+  } else if (hours >= 1) {
+    const remainingMinutes = minutes % 60;
+    return `${hours}h${remainingMinutes}m`;
+  } else {
+    return `${minutes}m`;
+  }
+}
+function formatWallClock(date, clockFormat) {
+  const now = new Date;
+  const dayOfWeek = date.toLocaleDateString("en-US", { weekday: "short" });
+  const month = date.toLocaleDateString("en-US", { month: "short" });
+  const dayOfMonth = date.getDate();
+  const isSameDay = date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+  const isSameMonth = date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth();
+  let timeStr;
+  if (clockFormat === "12h") {
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const ampm = hours >= 12 ? "pm" : "am";
+    const hour12 = hours % 12 || 12;
+    if (minutes === 0) {
+      timeStr = `${hour12}${ampm}`;
+    } else {
+      timeStr = `${hour12}:${minutes.toString().padStart(2, "0")}${ampm}`;
+    }
+  } else {
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    timeStr = `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+  }
+  if (isSameDay) {
+    return `${dayOfWeek} ${timeStr}`;
+  } else if (isSameMonth) {
+    return `${dayOfWeek} ${dayOfMonth} ${timeStr}`;
+  } else {
+    return `${month} ${dayOfMonth} ${timeStr}`;
+  }
+}
+
+// src/renderer/icons.ts
+var PROGRESS_ICONS = [
+  "\uDB80\uDD30",
+  "\uDB82\uDE9E",
+  "\uDB82\uDE9F",
+  "\uDB82\uDEA0",
+  "\uDB82\uDEA1",
+  "\uDB82\uDEA2",
+  "\uDB82\uDEA3",
+  "\uDB82\uDEA4",
+  "\uDB82\uDEA5"
+];
+function getProgressIcon(percent) {
+  if (percent === null) {
+    return PROGRESS_ICONS[0] ?? "";
+  }
+  const clampedPercent = Math.max(0, Math.min(100, percent));
+  const index = Math.min(8, Math.ceil(clampedPercent / 12.5));
+  return PROGRESS_ICONS[index] ?? PROGRESS_ICONS[0] ?? "";
+}
+
+// src/renderer/component.ts
+function renderComponent(componentId, data, componentConfig, globalConfig) {
+  const effectiveLayout = componentConfig.layout ?? globalConfig.display.layout;
+  const effectiveDisplayMode = componentConfig.displayMode ?? globalConfig.display.displayMode;
+  const effectiveBarSize = componentConfig.barSize ?? globalConfig.display.barSize;
+  const effectiveBarStyle = componentConfig.barStyle ?? globalConfig.display.barStyle;
+  const clockFormat = globalConfig.display.clockFormat;
+  switch (componentId) {
+    case "daily":
+      return renderQuotaComponent("daily", data.daily, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat);
+    case "weekly":
+      return renderQuotaComponent("weekly", data.weekly, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat);
+    case "monthly":
+      return renderQuotaComponent("monthly", data.monthly, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat);
+    case "balance":
+      return renderBalanceComponent(data.balance, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig);
+    case "tokens":
+      return renderTokensComponent(data.tokenStats, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig);
+    case "rateLimit":
+      return renderRateLimitComponent(data.rateLimit, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig);
+    case "plan":
+      return renderPlanComponent(data.planName, effectiveLayout, componentConfig, globalConfig);
+    default:
+      return null;
+  }
+}
+function renderQuotaComponent(componentId, quota, layout, displayMode, barSize, barStyle, componentConfig, globalConfig, clockFormat) {
+  if (!quota)
+    return null;
+  const usagePercent = calculateUsagePercent(quota.used, quota.limit);
+  const label = renderLabel(componentId, layout, componentConfig, globalConfig, displayMode);
+  const barColor = resolvePartColor("bar", usagePercent, componentConfig, globalConfig);
+  const valueColor = resolvePartColor("value", usagePercent, componentConfig, globalConfig);
+  const labelColor = resolvePartColor("label", usagePercent, componentConfig, globalConfig);
+  const countdownColor = resolvePartColor("countdown", usagePercent, componentConfig, globalConfig);
+  const display = renderDisplayMode(displayMode, usagePercent, barSize, barStyle, barColor, null);
+  const value = ansiColor(`${Math.round(usagePercent)}%`, valueColor);
+  const countdown = renderCountdownSubComponent(quota.resetsAt, componentConfig.countdown, countdownColor, clockFormat);
+  return assembleComponent(layout, label, labelColor, display, value, countdown);
+}
+function renderBalanceComponent(balance, layout, displayMode, barSize, barStyle, componentConfig, globalConfig) {
+  if (!balance)
+    return null;
+  const isUnlimited = balance.remaining === -1;
+  let usagePercent = null;
+  if (!isUnlimited && balance.initial !== null && balance.initial > 0) {
+    usagePercent = (balance.initial - balance.remaining) / balance.initial * 100;
+  }
+  const effectivePercent = isUnlimited ? 0 : usagePercent;
+  const label = renderLabel("balance", layout, componentConfig, globalConfig, displayMode);
+  const barColor = resolvePartColor("bar", effectivePercent, componentConfig, globalConfig);
+  const valueColor = resolvePartColor("value", effectivePercent, componentConfig, globalConfig);
+  const labelColor = resolvePartColor("label", effectivePercent, componentConfig, globalConfig);
+  const display = isUnlimited ? "" : renderDisplayMode(displayMode, effectivePercent ?? 0, barSize, barStyle, barColor, null);
+  const valueText = isUnlimited ? "∞" : `$${balance.remaining.toFixed(2)}`;
+  const value = ansiColor(valueText, valueColor);
+  const countdown = "";
+  return assembleComponent(layout, label, labelColor, display, value, countdown);
+}
+function renderTokensComponent(tokenStats, layout, displayMode, componentConfig, globalConfig) {
+  if (!tokenStats)
+    return null;
+  const stats = tokenStats.total ?? tokenStats.today;
+  if (!stats)
+    return null;
+  const label = renderLabel("tokens", layout, componentConfig, globalConfig, displayMode);
+  const labelColor = resolvePartColor("label", null, componentConfig, globalConfig);
+  const valueColor = resolvePartColor("value", null, componentConfig, globalConfig);
+  const tokenCount = stats.totalTokens ?? stats.inputTokens + stats.outputTokens;
+  const valueText = formatLargeNumber(tokenCount);
+  const value = ansiColor(valueText, valueColor);
+  const display = "";
+  const countdown = "";
+  return assembleComponent(layout, label, labelColor, display, value, countdown);
+}
+function renderRateLimitComponent(rateLimit, layout, displayMode, barSize, barStyle, componentConfig, globalConfig) {
+  if (!rateLimit)
+    return null;
+  let usagePercent = null;
+  if (rateLimit.requestsLimit !== null && rateLimit.requestsLimit > 0) {
+    usagePercent = rateLimit.requestsUsed / rateLimit.requestsLimit * 100;
+  }
+  const label = renderLabel("rateLimit", layout, componentConfig, globalConfig, displayMode);
+  const barColor = resolvePartColor("bar", usagePercent, componentConfig, globalConfig);
+  const valueColor = resolvePartColor("value", usagePercent, componentConfig, globalConfig);
+  const labelColor = resolvePartColor("label", usagePercent, componentConfig, globalConfig);
+  const display = usagePercent !== null ? renderDisplayMode(displayMode, usagePercent, barSize, barStyle, barColor, null) : "";
+  const valueText = rateLimit.requestsLimit !== null ? `${rateLimit.requestsUsed}/${rateLimit.requestsLimit}` : `${rateLimit.requestsUsed}`;
+  const value = ansiColor(valueText, valueColor);
+  const countdown = "";
+  return assembleComponent(layout, label, labelColor, display, value, countdown);
+}
+function renderPlanComponent(planName, layout, componentConfig, globalConfig) {
+  if (layout === "minimal")
+    return null;
+  const labelColor = resolvePartColor("label", null, componentConfig, globalConfig);
+  const value = ansiColor(planName, labelColor);
+  if (typeof componentConfig.label === "object" && componentConfig.label.text) {
+    const labelText = ansiColor(componentConfig.label.text, labelColor);
+    return `${labelText} ${value}`;
+  }
+  return value;
+}
+function renderLabel(componentId, layout, componentConfig, globalConfig, displayMode) {
+  if (layout === "minimal")
+    return "";
+  if (componentConfig.label === false)
+    return "";
+  if (displayMode === "icon-pct" && typeof componentConfig.label === "object" && componentConfig.label.icon) {
+    return componentConfig.label.icon;
+  }
+  if (typeof componentConfig.label === "string") {
+    return layout === "compact" ? componentConfig.label.charAt(0) : componentConfig.label;
+  }
+  if (typeof componentConfig.label === "object" && componentConfig.label.text) {
+    return layout === "compact" ? componentConfig.label.text.charAt(0) : componentConfig.label.text;
+  }
+  if (layout === "compact") {
+    return COMPONENT_SHORT_LABELS[componentId] ?? "";
+  }
+  return COMPONENT_FULL_LABELS[componentId] ?? "";
+}
+function renderDisplayMode(displayMode, usagePercent, barSize, barStyle, barColor, emptyColor) {
+  switch (displayMode) {
+    case "bar":
+      return renderBar(usagePercent, barSize, barStyle, barColor, emptyColor);
+    case "percentage":
+      return "";
+    case "icon-pct":
+      return getProgressIcon(usagePercent);
+    default:
+      return "";
+  }
+}
+function renderCountdownSubComponent(resetsAt, countdownConfig, countdownColor, clockFormat) {
+  if (countdownConfig === false || !resetsAt)
+    return "";
+  const config = typeof countdownConfig === "object" ? countdownConfig : {};
+  const countdown = renderCountdown(resetsAt, config, clockFormat);
+  return countdownColor ? ansiColor(countdown, countdownColor) : countdown;
+}
+function assembleComponent(layout, label, labelColor, display, value, countdown) {
+  const coloredLabel = label && labelColor ? ansiColor(label, labelColor) : label;
+  const parts = [];
+  if (layout === "minimal") {
+    if (display)
+      parts.push(display);
+    parts.push(value);
+    if (countdown)
+      parts.push(countdown);
+  } else if (layout === "percent-first") {
+    if (coloredLabel)
+      parts.push(coloredLabel);
+    parts.push(value);
+    if (display)
+      parts.push(display);
+    if (countdown)
+      parts.push(countdown);
+  } else {
+    if (coloredLabel)
+      parts.push(coloredLabel);
+    if (display)
+      parts.push(display);
+    parts.push(value);
+    if (countdown)
+      parts.push(countdown);
+  }
+  return parts.filter((p) => p).join(" ").replace(/ (\x1b\[[0-9;]*m)? ([·•])/g, "$1 $2");
+}
+function calculateUsagePercent(used, limit) {
+  if (limit === null || limit === 0)
+    return 0;
+  return used / limit * 100;
+}
+function resolvePartColor(part, usagePercent, componentConfig, globalConfig) {
+  if (componentConfig.colors && componentConfig.colors[part]) {
+    const partColor = componentConfig.colors[part];
+    return resolveColor(partColor ?? null, usagePercent, globalConfig);
+  }
+  const color = componentConfig.color ?? "auto";
+  return resolveColor(color, usagePercent, globalConfig);
+}
+function formatLargeNumber(n) {
+  if (n >= 1e9) {
+    return `${(n / 1e9).toFixed(1)}B`;
+  } else if (n >= 1e6) {
+    return `${(n / 1e6).toFixed(1)}M`;
+  } else if (n >= 1000) {
+    return `${(n / 1000).toFixed(1)}K`;
+  }
+  return n.toString();
+}
+
+// src/renderer/truncate.ts
+function getTerminalWidth() {
+  if (process.stdout.columns && process.stdout.columns > 0) {
+    return process.stdout.columns;
+  }
+  return 80;
+}
+function computeMaxWidth(termWidth, maxWidthPct) {
+  const pct = Math.max(20, Math.min(100, maxWidthPct));
+  return Math.floor(termWidth * pct / 100);
+}
+function visibleLength(text) {
+  const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
+  return stripped.length;
+}
+function ansiAwareTruncate(text, maxWidth) {
+  const visible = visibleLength(text);
+  if (visible <= maxWidth) {
+    return text;
+  }
+  const targetWidth = maxWidth - 1;
+  let output = "";
+  let visibleCount = 0;
+  let i = 0;
+  while (i < text.length && visibleCount < targetWidth) {
+    if (text[i] === "\x1B" && text[i + 1] === "[") {
+      const escapeStart = i;
+      i += 2;
+      while (i < text.length && text[i] !== undefined && /[0-9;]/.test(text[i])) {
+        i++;
+      }
+      if (i < text.length) {
+        i++;
+      }
+      output += text.slice(escapeStart, i);
+    } else {
+      const char = text[i];
+      if (char !== undefined) {
+        output += char;
+      }
+      visibleCount++;
+      i++;
+    }
+  }
+  return output + "…";
+}
+
+// src/renderer/index.ts
+var DEFAULT_COMPONENT_ORDER2 = [
+  "daily",
+  "weekly",
+  "monthly",
+  "balance",
+  "tokens",
+  "rateLimit",
+  "plan"
+];
+function renderStatusline(data, config, errorState, cacheAge) {
+  const componentOrder = getComponentOrder(config);
+  const renderedComponents = [];
+  for (const componentId of componentOrder) {
+    const componentConfig = config.components[componentId];
+    if (componentConfig === false) {
+      continue;
+    }
+    const rendered = renderComponent(componentId, data, componentConfig === true || componentConfig === undefined ? {} : componentConfig, config);
+    if (rendered !== null) {
+      renderedComponents.push(rendered);
+    }
+  }
+  const separator = config.display.separator ?? " | ";
+  let statusline = renderedComponents.join(separator);
+  if (errorState) {
+    const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
+    if (isTransition) {
+      statusline = renderError(errorState, "with-cache", data.provider, undefined, cacheAge);
+    } else {
+      const hasCache = renderedComponents.length > 0;
+      const errorMode = hasCache ? "with-cache" : "without-cache";
+      const errorIndicator = renderError(errorState, errorMode, data.provider, undefined, cacheAge);
+      if (hasCache) {
+        statusline = `${statusline} ${errorIndicator}`;
+      } else {
+        statusline = errorIndicator;
+      }
+    }
+  }
+  const termWidth = getTerminalWidth();
+  const maxWidth = computeMaxWidth(termWidth, config.display.maxWidth ?? 80);
+  statusline = ansiAwareTruncate(statusline, maxWidth);
+  return statusline;
+}
+function getComponentOrder(config) {
+  const explicitOrder = [];
+  const explicitSet = new Set;
+  for (const key of Object.keys(config.components)) {
+    if (isComponentId(key)) {
+      explicitOrder.push(key);
+      explicitSet.add(key);
+    }
+  }
+  const order = [...explicitOrder];
+  for (const componentId of DEFAULT_COMPONENT_ORDER2) {
+    if (!explicitSet.has(componentId)) {
+      order.push(componentId);
+    }
+  }
+  return order;
+}
+function isComponentId(key) {
+  return DEFAULT_COMPONENT_ORDER2.includes(key);
+}
+
+// src/core/execute-cycle.ts
+async function executeCycle(ctx) {
+  const { env, config, configHash, cachedEntry, providerId, provider, timeoutBudgetMs, startTime, fetchTimeoutMs } = ctx;
+  if (cachedEntry) {
+    if (isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
+      if (cachedEntry.renderedLine && isCacheRenderedLineUsable(cachedEntry, configHash)) {
+        logger.debug("Path A: Fast path (cached renderedLine)", {
+          cacheAge: `${Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 1000)}s`
+        });
+        return {
+          output: cachedEntry.renderedLine,
+          exitCode: 0,
+          cacheUpdate: null
+        };
+      }
+    }
+  }
+  if (cachedEntry && isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
+    logger.debug("Path B: Re-render (config changed, cache data valid)");
+    const statusline = renderStatusline(cachedEntry.data, config);
+    const updatedEntry = {
+      ...cachedEntry,
+      renderedLine: statusline,
+      configHash
+    };
+    return {
+      output: statusline,
+      exitCode: 0,
+      cacheUpdate: updatedEntry
+    };
+  }
+  const deadline = startTime + timeoutBudgetMs - 50;
+  const remainingBudget = deadline - Date.now();
+  if (remainingBudget <= 50) {
+    logger.debug("Path D: Timeout fallback (insufficient budget)", { remainingBudget });
+    if (cachedEntry && cachedEntry.renderedLine) {
+      return {
+        output: cachedEntry.renderedLine,
+        exitCode: 0,
+        cacheUpdate: null
+      };
+    } else {
+      return {
+        output: "[loading...]",
+        exitCode: 0,
+        cacheUpdate: null
+      };
+    }
+  }
+  try {
+    const baseUrl = env.baseUrl;
+    const authToken = env.authToken;
+    if (!baseUrl || !authToken) {
+      return {
+        output: renderError("missing-env", "without-cache"),
+        exitCode: 1,
+        cacheUpdate: null
+      };
+    }
+    logger.debug("Path C: Fetching from provider", { providerId, fetchTimeoutMs });
+    const fetchStart = Date.now();
+    const data = await provider.fetch(baseUrl, authToken, config, fetchTimeoutMs);
+    const fetchTime = Date.now() - fetchStart;
+    logger.debug("Fetch completed", { fetchTime: `${fetchTime}ms` });
+    const statusline = renderStatusline(data, config);
+    const ttlSeconds = getEffectivePollInterval(config, env.pollIntervalOverride);
+    const newEntry = {
+      version: CACHE_VERSION,
+      baseUrl,
+      tokenHash: env.tokenHash ?? "",
+      provider: providerId,
+      fetchedAt: data.fetchedAt,
+      ttlSeconds,
+      data,
+      renderedLine: statusline,
+      configHash
+    };
+    return {
+      output: statusline,
+      exitCode: 0,
+      cacheUpdate: newEntry
+    };
+  } catch (error) {
+    logger.error("Path D: Fetch error", { error: String(error), hasCachedEntry: !!cachedEntry });
+    if (cachedEntry) {
+      const ageMinutes = Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 60000);
+      const statusline = renderStatusline(cachedEntry.data, config, "network-error", ageMinutes);
+      logger.debug("Using stale cache with error indicator", { ageMinutes });
+      return {
+        output: statusline,
+        exitCode: 0,
+        cacheUpdate: null
+      };
+    } else {
+      logger.warn("No cache available for error fallback");
+      const errorOutput = renderError("network-error", "without-cache", providerId);
+      return {
+        output: errorOutput,
+        exitCode: 1,
+        cacheUpdate: null
+      };
+    }
+  }
+}
+// src/services/settings.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, renameSync as renameSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname2 } from "path";
+import { execSync as execSync2 } from "child_process";
+function loadClaudeSettings() {
+  const path = getSettingsJsonPath();
+  if (!existsSync5(path)) {
+    return {};
+  }
+  try {
+    const content = readFileSync4(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`Failed to read settings from ${path}: ${error}`);
+    return {};
+  }
+}
+function saveClaudeSettings(settings) {
+  const path = getSettingsJsonPath();
+  const tmpPath = `${path}.tmp`;
+  try {
+    const dir = dirname2(path);
+    if (!existsSync5(dir)) {
+      mkdirSync4(dir, { recursive: true, mode: 448 });
+    }
+    const content = JSON.stringify(settings, null, 2) + `
+`;
+    writeFileSync3(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    renameSync3(tmpPath, path);
+  } catch (error) {
+    console.error(`Failed to write settings to ${path}: ${error}`);
+    try {
+      if (existsSync5(tmpPath)) {
+        unlinkSync3(tmpPath);
+      }
+    } catch {}
+    throw error;
+  }
+}
+function getExistingStatusLine() {
+  const settings = loadClaudeSettings();
+  return settings.statusLine?.command ?? null;
+}
+function isBunxAvailable() {
+  try {
+    execSync2("which bunx", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installStatusLine(runner) {
+  const settings = loadClaudeSettings();
+  settings.statusLine = {
+    type: "command",
+    command: `${runner} -y cc-api-statusline@latest`,
+    padding: 0
+  };
+  saveClaudeSettings(settings);
+}
+function uninstallStatusLine() {
+  const settings = loadClaudeSettings();
+  if ("statusLine" in settings) {
+    delete settings.statusLine;
+    saveClaudeSettings(settings);
+  }
+}
+// package.json
+var package_default = {
+  name: "cc-api-statusline",
+  version: "0.1.0",
+  description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
+  type: "module",
+  bin: {
+    "cc-api-statusline": "dist/cc-api-statusline.js"
+  },
+  scripts: {
+    start: "bun run src/main.ts --once",
+    dev: "bun run src/main.ts",
+    example: "cat docs/fixtures/ccstatusline-context.sample.json | bun run src/main.ts",
+    test: "bun run build && vitest run",
+    "test:watch": "vitest",
+    lint: "eslint src",
+    build: "bun build src/main.ts --target=node --outfile=dist/cc-api-statusline.js",
+    check: "bun run test && bun run lint",
+    prepublishOnly: "bun run check"
+  },
+  files: [
+    "dist/"
+  ],
+  keywords: [
+    "claude",
+    "statusline",
+    "api",
+    "usage",
+    "monitoring",
+    "tui",
+    "cli"
+  ],
+  author: "Liafonx",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/liafonx/cc-api-statusline.git"
+  },
+  homepage: "https://github.com/liafonx/cc-api-statusline#readme",
+  bugs: {
+    url: "https://github.com/liafonx/cc-api-statusline/issues"
+  },
+  dependencies: {},
+  devDependencies: {
+    "@eslint/js": "^9.17.0",
+    "@types/bun": "^1.1.14",
+    eslint: "^9.17.0",
+    typescript: "^5.7.2",
+    "typescript-eslint": "^8.18.2",
+    vitest: "^2.1.8"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
+
+// src/main.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let help = false;
+  let version = false;
+  let once = false;
+  let install = false;
+  let uninstall = false;
+  let force = false;
+  let configPath;
+  let runner;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      version = true;
+    } else if (arg === "--once") {
+      once = true;
+    } else if (arg === "--install") {
+      install = true;
+    } else if (arg === "--uninstall") {
+      uninstall = true;
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--config" && i + 1 < args.length) {
+      configPath = args[i + 1];
+      i++;
+    } else if (arg === "--runner" && i + 1 < args.length) {
+      const nextArg = args[i + 1];
+      if (nextArg === "npx" || nextArg === "bunx") {
+        runner = nextArg;
+      }
+      i++;
+    }
+  }
+  return { help, version, once, install, uninstall, force, configPath, runner };
+}
+function showHelp() {
+  console.log(`
+cc-api-statusline — Claude API statusline widget
+
+Usage:
+  cc-api-statusline [options]
+
+Options:
+  --help, -h         Show this help message
+  --version, -v      Show version
+  --once             Fetch once and exit (no polling)
+  --config <path>    Use custom config file
+  --install          Register as Claude Code statusline widget
+  --uninstall        Remove statusline widget registration
+  --runner <runner>  Package runner: npx or bunx (default: auto-detect)
+  --force            Force overwrite existing statusline configuration
+
+Environment Variables:
+  ANTHROPIC_BASE_URL       API endpoint (required)
+  ANTHROPIC_AUTH_TOKEN     API key (required)
+  CC_STATUSLINE_PROVIDER   Override provider detection
+  CC_STATUSLINE_POLL       Override poll interval (seconds)
+  CC_STATUSLINE_TIMEOUT    Piped mode timeout (milliseconds, default 1000)
+  DEBUG or CC_STATUSLINE_DEBUG  Enable debug logging to ~/.claude/cc-api-statusline/debug.log
+
+Config File:
+  ~/.claude/cc-api-statusline/config.json
+
+Documentation:
+  https://github.com/liafonx/cc-api-statusline
+  `.trim());
+}
+function showVersion() {
+  console.log(`cc-api-statusline v${package_default.version}`);
+}
+function discardStdin() {
+  if (!process.stdin.isTTY) {
+    process.stdin.resume();
+    process.stdin.on("data", () => {});
+  }
+}
+async function main() {
+  const startTime = Date.now();
+  logger.debug("=== cc-api-statusline execution started ===");
+  logger.debug("Start time", { startTime, version: package_default.version });
+  discardStdin();
+  const args = parseArgs();
+  logger.debug("Parsed arguments", { args });
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+  if (args.version) {
+    showVersion();
+    process.exit(0);
+  }
+  if (args.install) {
+    const existing = getExistingStatusLine();
+    if (existing && !args.force) {
+      console.error("Error: statusLine is already configured in settings.json");
+      console.error(`Current command: ${existing}`);
+      console.error("Use --force to overwrite, or --uninstall to remove first.");
+      process.exit(1);
+    }
+    const runner = args.runner ?? (isBunxAvailable() ? "bunx" : "npx");
+    installStatusLine(runner);
+    console.log("✓ Statusline installed successfully!");
+    console.log(`  Runner: ${runner}`);
+    console.log(`  Command: ${runner} -y cc-api-statusline@latest`);
+    console.log(`  Config: ~/.claude/settings.json`);
+    process.exit(0);
+  }
+  if (args.uninstall) {
+    const existing = getExistingStatusLine();
+    if (!existing) {
+      console.log("No statusLine configuration found in settings.json");
+      process.exit(0);
+    }
+    uninstallStatusLine();
+    console.log("✓ Statusline uninstalled successfully");
+    console.log("  Removed statusLine from ~/.claude/settings.json");
+    process.exit(0);
+  }
+  const isPiped = !process.stdin.isTTY;
+  logger.debug("Mode detection", { isPiped, once: args.once });
+  if (!isPiped && !args.once) {
+    console.log("Interactive configuration mode coming soon.");
+    console.log("Use --once for a single fetch, or configure as a Claude Code statusline command.");
+    process.exit(0);
+  }
+  const env = readCurrentEnv();
+  logger.debug("Environment loaded", {
+    baseUrl: env.baseUrl ? `${env.baseUrl.substring(0, 30)}...` : undefined,
+    hasToken: !!env.authToken,
+    providerOverride: env.providerOverride,
+    pollIntervalOverride: env.pollIntervalOverride
+  });
+  const envError = validateRequiredEnv(env);
+  if (envError) {
+    const errorOutput = renderError("missing-env", "without-cache");
+    process.stdout.write(errorOutput);
+    process.exit(1);
+  }
+  const baseUrl = env.baseUrl;
+  const authToken = env.authToken;
+  if (!baseUrl || !authToken) {
+    process.exit(1);
+  }
+  const config = loadConfig(args.configPath);
+  const configPath = getConfigPath(args.configPath);
+  const configHash = computeConfigHash(configPath);
+  logger.debug("Config loaded", { configPath, configHash });
+  const providerId = resolveProvider(baseUrl, env.providerOverride, config.customProviders ?? {});
+  const provider = getProvider(providerId, config.customProviders ?? {});
+  logger.debug("Provider resolved", { providerId });
+  if (!provider) {
+    logger.error("Provider not found", { providerId });
+    const errorOutput = renderError("provider-unknown", "without-cache");
+    process.stdout.write(errorOutput);
+    process.exit(1);
+  }
+  const cachedEntry = readCache(baseUrl);
+  logger.debug("Cache read", {
+    cacheHit: !!cachedEntry,
+    cacheAge: cachedEntry ? `${Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 1000)}s` : "N/A"
+  });
+  const timeoutBudgetMs = isPiped ? Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000) : 1e4;
+  const fetchTimeoutMs = isPiped ? Math.min(config.pipedRequestTimeoutMs ?? 800, timeoutBudgetMs - 100) : 1e4;
+  const ctx = {
+    env,
+    config,
+    configHash,
+    cachedEntry,
+    providerId,
+    provider,
+    timeoutBudgetMs,
+    startTime,
+    fetchTimeoutMs
+  };
+  logger.debug("Execution context prepared", { timeoutBudgetMs, fetchTimeoutMs });
+  const result = await executeCycle(ctx);
+  const executionTime = Date.now() - startTime;
+  logger.debug("Execution completed", {
+    exitCode: result.exitCode,
+    executionTime: `${executionTime}ms`,
+    outputLength: result.output.length,
+    cacheUpdate: !!result.cacheUpdate
+  });
+  if (isPiped) {
+    const formatted = "\x1B[0m" + result.output.replace(/ /g, " ");
+    process.stdout.write(formatted);
+    logger.debug("Output formatted for piped mode (ANSI reset + NBSP)");
+  } else {
+    process.stdout.write(result.output);
+    logger.debug("Output written (TTY mode)");
+  }
+  if (result.cacheUpdate) {
+    writeCache(baseUrl, result.cacheUpdate);
+    logger.debug("Cache updated");
+  }
+  logger.debug("=== Execution finished ===", { exitCode: result.exitCode });
+  process.exit(result.exitCode);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});