cc-api-statusline 0.2.2 → 1.0.0

package/dist/cc-api-statusline.js

@@ -4,7 +4,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // package.json
 var package_default = {
   name: "cc-api-statusline",
-  version: "0.2.2",
+  version: "1.0.0",
   description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
   type: "module",
   bin: {
@@ -138,13 +138,13 @@ function showVersion() {
   console.log(`cc-api-statusline v${package_default.version}`);
 }
 // src/services/settings.ts
-import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { execSync } from "child_process";
 
 // src/services/env.ts
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { readFileSync } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/services/hash.ts
 function sha256(input) {
@@ -161,21 +161,193 @@ function shortHash(input, length = 12) {
   return fullHash.slice(0, length);
 }
 
+// src/services/logger.ts
+import { appendFileSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+
+// src/services/ensure-dir.ts
+import { mkdirSync } from "fs";
+function ensureDir(dirPath) {
+  mkdirSync(dirPath, { recursive: true, mode: 448 });
+}
+
+// src/services/log-rotator.ts
+import { statSync, renameSync, readdirSync, unlinkSync } from "fs";
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+
+// src/core/constants.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 5000;
+var EXIT_BUFFER_MS = 50;
+var STALENESS_THRESHOLD_MINUTES = 5;
+var VERY_STALE_THRESHOLD_MINUTES = 30;
+var GC_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+var GC_MAX_CACHE_FILES = 20;
+var GC_ORPHAN_TMP_AGE_MS = 60 * 60 * 1000;
+var LOG_ROTATION_PROBABILITY = 0.05;
+var LOG_MAX_SIZE_BYTES = 512 * 1024;
+var LOG_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+var LOG_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
+
+// src/services/log-rotator.ts
+var ARCHIVE_LOG_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log$/;
+var ARCHIVE_GZ_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log\.gz$/;
+function archiveName(logPath, now = new Date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const y = now.getFullYear();
+  const mo = pad(now.getMonth() + 1);
+  const d = pad(now.getDate());
+  const h = pad(now.getHours());
+  const min = pad(now.getMinutes());
+  return join(dirname(logPath), `debug.${y}-${mo}-${d}T${h}-${min}.log`);
+}
+function spawnGzip(filePath) {
+  try {
+    const child = spawn("gzip", ["-f", filePath], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {}
+}
+function runCleanup(logDir, excludePath) {
+  try {
+    const files = readdirSync(logDir);
+    const now = Date.now();
+    for (const name of files) {
+      const filePath = join(logDir, name);
+      if (filePath === excludePath)
+        continue;
+      if (ARCHIVE_LOG_RE.test(name)) {
+        const s = statSync(filePath, { throwIfNoEntry: false });
+        if (s && now - s.mtimeMs >= LOG_MAX_AGE_MS) {
+          spawnGzip(filePath);
+        }
+        continue;
+      }
+      if (ARCHIVE_GZ_RE.test(name)) {
+        const s = statSync(filePath, { throwIfNoEntry: false });
+        if (s && now - s.mtimeMs >= LOG_RETENTION_MS) {
+          try {
+            unlinkSync(filePath);
+          } catch {}
+        }
+      }
+    }
+  } catch {}
+}
+function maybeRotateLogs(logPath) {
+  if (Math.random() > LOG_ROTATION_PROBABILITY)
+    return;
+  const logDir = dirname(logPath);
+  const stat = statSync(logPath, { throwIfNoEntry: false });
+  let rotatedArchive = null;
+  if (stat) {
+    const age = Date.now() - stat.mtimeMs;
+    const archive = archiveName(logPath);
+    try {
+      if (age >= LOG_MAX_AGE_MS) {
+        renameSync(logPath, archive);
+        spawnGzip(archive);
+        rotatedArchive = archive;
+      } else if (stat.size >= LOG_MAX_SIZE_BYTES) {
+        renameSync(logPath, archive);
+        rotatedArchive = archive;
+      }
+    } catch {}
+  }
+  runCleanup(logDir, rotatedArchive);
+}
+
+// src/services/paths.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function getConfigDir() {
+  return join2(homedir(), ".claude", "cc-api-statusline");
+}
+
+// src/services/logger.ts
+class Logger {
+  enabled;
+  logPath;
+  constructor() {
+    this.enabled = !!(process.env["DEBUG"] || process.env["CC_STATUSLINE_DEBUG"]);
+    const logDir = process.env["CC_API_STATUSLINE_LOG_DIR"] || getConfigDir();
+    this.logPath = join3(logDir, "debug.log");
+    if (this.enabled) {
+      this.ensureLogDir();
+      maybeRotateLogs(this.logPath);
+    }
+  }
+  ensureLogDir() {
+    try {
+      const dir = dirname2(this.logPath);
+      ensureDir(dir);
+    } catch {
+      this.enabled = false;
+    }
+  }
+  formatLocalTimestamp() {
+    const d = new Date;
+    const pad = (n, len = 2) => n.toString().padStart(len, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+  }
+  format(level, message, data) {
+    const timestamp = this.formatLocalTimestamp();
+    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/env.ts
 function getSettingsJsonPath() {
   const configDir = process.env["CLAUDE_CONFIG_DIR"];
   if (configDir) {
-    return join(configDir, "settings.json");
+    return join4(configDir, "settings.json");
   }
-  return join(homedir(), ".claude", "settings.json");
+  return join4(homedir2(), ".claude", "settings.json");
 }
 function readSettingsJsonEnv() {
   const settingsPath = getSettingsJsonPath();
-  if (!existsSync(settingsPath)) {
-    return {};
+  let content;
+  try {
+    content = readFileSync(settingsPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return {};
+    }
+    throw err;
   }
   try {
-    const content = readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     if (settings["env"] && typeof settings["env"] === "object") {
       const env = settings["env"];
@@ -190,8 +362,8 @@ function readSettingsJsonEnv() {
       return result;
     }
     return {};
-  } catch (error) {
-    console.warn(`Warning: Could not read settings.json: ${error}`);
+  } catch (err) {
+    logger.warn(`Could not read settings.json: ${err}`);
     return {};
   }
 }
@@ -231,25 +403,15 @@ function validateRequiredEnv(env) {
 }
 
 // src/services/atomic-write.ts
-import { writeFileSync, renameSync, unlinkSync, existsSync as existsSync3, chmodSync } from "fs";
-import { dirname } from "path";
-
-// src/services/ensure-dir.ts
-import { mkdirSync, existsSync as existsSync2 } from "fs";
-function ensureDir(dirPath) {
-  if (!existsSync2(dirPath)) {
-    mkdirSync(dirPath, { recursive: true, mode: 448 });
-  }
-}
-
-// src/services/atomic-write.ts
+import { writeFileSync, renameSync as renameSync2, unlinkSync as unlinkSync2, existsSync, chmodSync } from "fs";
+import { dirname as dirname3 } from "path";
 function atomicWriteFile(filePath, content, opts = {}) {
   const { mode = 384, ensureParentDir: ensureParent = false, appendNewline = false } = opts;
   const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const tmpPath = `${filePath}.${nonce}.tmp`;
   try {
     if (ensureParent) {
-      const dir = dirname(filePath);
+      const dir = dirname3(filePath);
       ensureDir(dir);
     }
     const finalContent = appendNewline ? `${content}
@@ -258,11 +420,11 @@ function atomicWriteFile(filePath, content, opts = {}) {
     try {
       chmodSync(tmpPath, mode);
     } catch {}
-    renameSync(tmpPath, filePath);
+    renameSync2(tmpPath, filePath);
   } catch (error) {
     try {
-      if (existsSync3(tmpPath)) {
-        unlinkSync(tmpPath);
+      if (existsSync(tmpPath)) {
+        unlinkSync2(tmpPath);
       }
     } catch {}
     throw new Error(`Failed to write file atomically: ${error}`);
@@ -272,14 +434,14 @@ function atomicWriteFile(filePath, content, opts = {}) {
 // src/services/settings.ts
 function loadClaudeSettings() {
   const path = getSettingsJsonPath();
-  if (!existsSync4(path)) {
+  if (!existsSync2(path)) {
     return {};
   }
   try {
     const content = readFileSync2(path, "utf-8");
     return JSON.parse(content);
   } catch (error) {
-    console.warn(`Failed to read settings from ${path}: ${error}`);
+    logger.warn(`Failed to read settings from ${path}: ${error}`);
     return {};
   }
 }
@@ -326,9 +488,8 @@ function uninstallStatusLine() {
 }
 
 // src/services/config-defaults.ts
-import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
-import { existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
+import { existsSync as existsSync4 } from "fs";
 
 // src/types/normalized-usage.ts
 function createEmptyNormalizedUsage(provider, billingMode, planName) {
@@ -361,6 +522,14 @@ function computeSoonestReset(usage) {
   return sorted[0] ?? null;
 }
 // src/types/config.ts
+var DEFAULT_DIVIDER_CONFIG = { text: "|", margin: 1, color: "#555753" };
+var DEFAULT_TIER_THRESHOLDS = [37.5, 62.5, 75, 87.5, 100];
+function buildTiers(colors, thresholds = DEFAULT_TIER_THRESHOLDS) {
+  if (colors.length !== thresholds.length) {
+    throw new Error(`buildTiers: colors.length (${colors.length}) must equal thresholds.length (${thresholds.length})`);
+  }
+  return colors.map((color, i) => ({ color, maxPercent: thresholds[i] }));
+}
 var DEFAULT_CONFIG = {
   display: {
     layout: "standard",
@@ -368,7 +537,7 @@ var DEFAULT_CONFIG = {
     progressStyle: "icon",
     barSize: "medium",
     barStyle: "block",
-    separator: " | ",
+    divider: DEFAULT_DIVIDER_CONFIG,
     maxWidth: 100,
     clockFormat: "24h",
     colorMode: "auto",
@@ -381,73 +550,16 @@ var DEFAULT_CONFIG = {
     balance: true,
     tokens: false,
     rateLimit: false,
-    plan: false,
-    divider: true
+    plan: false
   },
   colors: {
-    auto: {
-      tiers: [
-        { color: "cool", maxPercent: 37.5 },
-        { color: "comfortable", maxPercent: 62.5 },
-        { color: "warm", maxPercent: 75 },
-        { color: "hot", maxPercent: 85 },
-        { color: "critical", maxPercent: 92.5 }
-      ]
-    },
-    vibrant: {
-      tiers: [
-        { color: "#00D9FF", maxPercent: 37.5 },
-        { color: "#4ADE80", maxPercent: 62.5 },
-        { color: "#FDE047", maxPercent: 75 },
-        { color: "#FB923C", maxPercent: 85 },
-        { color: "#F87171", maxPercent: 92.5 }
-      ]
-    },
-    pastel: {
-      tiers: [
-        { color: "pastel-cool", maxPercent: 37.5 },
-        { color: "pastel-comfortable", maxPercent: 62.5 },
-        { color: "pastel-medium", maxPercent: 75 },
-        { color: "pastel-warm", maxPercent: 85 },
-        { color: "pastel-hot", maxPercent: 92.5 }
-      ]
-    },
-    bright: {
-      tiers: [
-        { color: "bright-cool", maxPercent: 37.5 },
-        { color: "bright-comfortable", maxPercent: 62.5 },
-        { color: "bright-medium", maxPercent: 75 },
-        { color: "bright-warm", maxPercent: 85 },
-        { color: "bright-hot", maxPercent: 92.5 }
-      ]
-    },
-    ocean: {
-      tiers: [
-        { color: "ocean-cool", maxPercent: 37.5 },
-        { color: "ocean-comfortable", maxPercent: 62.5 },
-        { color: "ocean-medium", maxPercent: 75 },
-        { color: "ocean-warm", maxPercent: 85 },
-        { color: "ocean-hot", maxPercent: 92.5 }
-      ]
-    },
-    neutral: {
-      tiers: [
-        { color: "neutral-cool", maxPercent: 37.5 },
-        { color: "neutral-comfortable", maxPercent: 62.5 },
-        { color: "neutral-warm", maxPercent: 75 },
-        { color: "neutral-hot", maxPercent: 85 },
-        { color: "neutral-critical", maxPercent: 92.5 }
-      ]
-    },
-    chill: {
-      tiers: [
-        { color: "cyan", maxPercent: 37.5 },
-        { color: "cyan", maxPercent: 62.5 },
-        { color: "blue", maxPercent: 75 },
-        { color: "blue", maxPercent: 87.5 },
-        { color: "magenta", maxPercent: 92.5 }
-      ]
-    }
+    auto: { tiers: buildTiers(["cool", "comfortable", "warm", "hot", "critical"]) },
+    vibrant: { tiers: buildTiers(["#00D9FF", "#4ADE80", "#FDE047", "#FB923C", "#F87171"]) },
+    pastel: { tiers: buildTiers(["pastel-cool", "pastel-comfortable", "pastel-medium", "pastel-warm", "pastel-hot"]) },
+    bright: { tiers: buildTiers(["bright-cool", "bright-comfortable", "bright-medium", "bright-warm", "bright-hot"]) },
+    ocean: { tiers: buildTiers(["ocean-cool", "ocean-comfortable", "ocean-medium", "ocean-warm", "ocean-hot"]) },
+    neutral: { tiers: buildTiers(["neutral-cool", "neutral-comfortable", "neutral-warm", "neutral-hot", "neutral-critical"]) },
+    chill: { tiers: buildTiers(["cyan", "cyan", "blue", "blue", "magenta"]) }
   },
   pollIntervalSeconds: 30,
   pipedRequestTimeoutMs: 800
@@ -478,226 +590,68 @@ var COMPONENT_SHORT_LABELS = {
   rateLimit: "R",
   plan: "P"
 };
-var COMPONENT_FULL_LABELS = {
-  daily: "Daily",
-  weekly: "Weekly",
-  monthly: "Monthly",
-  balance: "Balance",
-  tokens: "Tokens",
-  rateLimit: "Rate",
-  plan: "Plan"
-};
-var COMPONENT_EMOJI_LABELS = {
-  daily: "\uD83D\uDCC5",
-  weekly: "\uD83D\uDCC6",
-  monthly: "\uD83D\uDDD3️",
-  balance: "\uD83D\uDCB0",
-  tokens: "\uD83D\uDD22",
-  rateLimit: "⚡",
-  plan: "\uD83D\uDCCB"
-};
-var COMPONENT_NERD_LABELS = {
-  daily: "",
-  weekly: "",
-  monthly: "",
-  balance: "",
-  tokens: "",
-  rateLimit: "",
-  plan: ""
-};
-var DEFAULT_COMPONENT_ORDER = [
-  "daily",
-  "weekly",
-  "monthly",
-  "balance",
-  "tokens",
-  "rateLimit",
-  "plan"
-];
-// src/types/cache.ts
-var CACHE_VERSION = 2;
-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["endpointConfigHash"] === "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");
-}
-var PROVIDER_DETECTION_TTL_SECONDS = 86400;
-function isProviderDetectionCacheEntry(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const c = value;
-  return typeof c["baseUrl"] === "string" && typeof c["provider"] === "string" && (c["detectedVia"] === "health-probe" || c["detectedVia"] === "url-pattern" || c["detectedVia"] === "override") && typeof c["detectedAt"] === "string" && typeof c["ttlSeconds"] === "number";
-}
-// src/services/endpoint-config.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
-
-// src/services/logger.ts
-import { appendFileSync } from "fs";
-import { join as join3, dirname as dirname3 } from "path";
-import { homedir as homedir2 } from "os";
-
-// src/services/log-rotator.ts
-import { statSync, renameSync as renameSync2, readdirSync, unlinkSync as unlinkSync2 } from "fs";
-import { spawn } from "child_process";
-import { dirname as dirname2, join as join2 } from "path";
-
-// src/core/constants.ts
-var DEFAULT_FETCH_TIMEOUT_MS = 5000;
-var EXIT_BUFFER_MS = 50;
-var STALENESS_THRESHOLD_MINUTES = 5;
-var VERY_STALE_THRESHOLD_MINUTES = 30;
-var GC_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-var GC_MAX_CACHE_FILES = 20;
-var GC_ORPHAN_TMP_AGE_MS = 60 * 60 * 1000;
-var LOG_ROTATION_PROBABILITY = 0.05;
-var LOG_MAX_SIZE_BYTES = 512 * 1024;
-var LOG_MAX_AGE_MS = 24 * 60 * 60 * 1000;
-var LOG_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
-
-// src/services/log-rotator.ts
-var ARCHIVE_LOG_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log$/;
-var ARCHIVE_GZ_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log\.gz$/;
-function archiveName(logPath, now = new Date) {
-  const pad = (n) => n.toString().padStart(2, "0");
-  const y = now.getFullYear();
-  const mo = pad(now.getMonth() + 1);
-  const d = pad(now.getDate());
-  const h = pad(now.getHours());
-  const min = pad(now.getMinutes());
-  return join2(dirname2(logPath), `debug.${y}-${mo}-${d}T${h}-${min}.log`);
-}
-function spawnGzip(filePath) {
-  try {
-    const child = spawn("gzip", ["-f", filePath], {
-      detached: true,
-      stdio: "ignore"
-    });
-    child.unref();
-  } catch {}
-}
-function runCleanup(logDir, excludePath) {
-  try {
-    const files = readdirSync(logDir);
-    const now = Date.now();
-    for (const name of files) {
-      const filePath = join2(logDir, name);
-      if (filePath === excludePath)
-        continue;
-      if (ARCHIVE_LOG_RE.test(name)) {
-        const s = statSync(filePath, { throwIfNoEntry: false });
-        if (s && now - s.mtimeMs >= LOG_MAX_AGE_MS) {
-          spawnGzip(filePath);
-        }
-        continue;
-      }
-      if (ARCHIVE_GZ_RE.test(name)) {
-        const s = statSync(filePath, { throwIfNoEntry: false });
-        if (s && now - s.mtimeMs >= LOG_RETENTION_MS) {
-          try {
-            unlinkSync2(filePath);
-          } catch {}
-        }
-      }
-    }
-  } catch {}
-}
-function maybeRotateLogs(logPath) {
-  if (Math.random() > LOG_ROTATION_PROBABILITY)
-    return;
-  const logDir = dirname2(logPath);
-  const stat = statSync(logPath, { throwIfNoEntry: false });
-  let rotatedArchive = null;
-  if (stat) {
-    const age = Date.now() - stat.mtimeMs;
-    const archive = archiveName(logPath);
-    try {
-      if (age >= LOG_MAX_AGE_MS) {
-        renameSync2(logPath, archive);
-        spawnGzip(archive);
-        rotatedArchive = archive;
-      } else if (stat.size >= LOG_MAX_SIZE_BYTES) {
-        renameSync2(logPath, archive);
-        rotatedArchive = archive;
-      }
-    } catch {}
-  }
-  runCleanup(logDir, rotatedArchive);
-}
-
-// src/services/logger.ts
-class Logger {
-  enabled;
-  logPath;
-  constructor() {
-    this.enabled = !!(process.env["DEBUG"] || process.env["CC_STATUSLINE_DEBUG"]);
-    const logDir = process.env["CC_API_STATUSLINE_LOG_DIR"] || join3(homedir2(), ".claude", "cc-api-statusline");
-    this.logPath = join3(logDir, "debug.log");
-    if (this.enabled) {
-      this.ensureLogDir();
-      maybeRotateLogs(this.logPath);
-    }
-  }
-  ensureLogDir() {
-    try {
-      const dir = dirname3(this.logPath);
-      ensureDir(dir);
-    } catch {
-      this.enabled = false;
-    }
-  }
-  formatLocalTimestamp() {
-    const d = new Date;
-    const pad = (n, len = 2) => n.toString().padStart(len, "0");
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
-  }
-  format(level, message, data) {
-    const timestamp = this.formatLocalTimestamp();
-    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 COMPONENT_FULL_LABELS = {
+  daily: "Daily",
+  weekly: "Weekly",
+  monthly: "Monthly",
+  balance: "Balance",
+  tokens: "Tokens",
+  rateLimit: "Rate",
+  plan: "Plan"
+};
+var COMPONENT_EMOJI_LABELS = {
+  daily: "\uD83D\uDCC5",
+  weekly: "\uD83D\uDCC6",
+  monthly: "\uD83D\uDDD3️",
+  balance: "\uD83D\uDCB0",
+  tokens: "\uD83D\uDD22",
+  rateLimit: "⚡",
+  plan: "\uD83D\uDCCB"
+};
+var COMPONENT_NERD_LABELS = {
+  daily: "",
+  weekly: "",
+  monthly: "",
+  balance: "",
+  tokens: "",
+  rateLimit: "",
+  plan: ""
+};
+var DEFAULT_COMPONENT_ORDER = [
+  "daily",
+  "weekly",
+  "monthly",
+  "balance",
+  "tokens",
+  "rateLimit",
+  "plan"
+];
+// src/types/cache.ts
+var CACHE_VERSION = 2;
+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["endpointConfigHash"] === "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");
+}
+var PROVIDER_DETECTION_TTL_SECONDS = 86400;
+function isProviderDetectionCacheEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const c = value;
+  return typeof c["baseUrl"] === "string" && typeof c["provider"] === "string" && (c["detectedVia"] === "health-probe" || c["detectedVia"] === "url-pattern" || c["detectedVia"] === "override") && typeof c["detectedAt"] === "string" && typeof c["ttlSeconds"] === "number";
 }
-var logger = new Logger;
-
 // src/services/endpoint-config.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
 function getEndpointConfigDir(customRoot) {
   const envRoot = process.env["CC_API_STATUSLINE_CONFIG_DIR"];
-  const root = customRoot || envRoot || join4(homedir3(), ".claude", "cc-api-statusline");
-  return join4(root, "api-config");
+  const root = customRoot || envRoot || getConfigDir();
+  return join5(root, "api-config");
 }
 function loadEndpointConfigs(customDir) {
   const configDir = getEndpointConfigDir(customDir);
-  if (!existsSync5(configDir)) {
+  if (!existsSync3(configDir)) {
     return getBuiltInEndpointConfigs();
   }
   const registry = {};
@@ -706,7 +660,7 @@ function loadEndpointConfigs(customDir) {
     return getBuiltInEndpointConfigs();
   }
   for (const file of files) {
-    const filePath = join4(configDir, file);
+    const filePath = join5(configDir, file);
     try {
       const config = loadEndpointConfigFile(filePath);
       registry[config.provider] = config;
@@ -771,20 +725,20 @@ function validateEndpointConfig(data, filename) {
 }
 function computeEndpointConfigHash(customDir) {
   const configDir = getEndpointConfigDir(customDir);
-  if (!existsSync5(configDir)) {
+  if (!existsSync3(configDir)) {
     const builtIn = getBuiltInEndpointConfigs();
     const serialized = JSON.stringify(builtIn, Object.keys(builtIn).sort());
-    return sha256(serialized).slice(0, 12);
+    return shortHash(serialized, 12);
   }
   const files = readdirSync2(configDir).filter((f) => f.endsWith(".json")).sort();
   if (files.length === 0) {
     const builtIn = getBuiltInEndpointConfigs();
     const serialized = JSON.stringify(builtIn, Object.keys(builtIn).sort());
-    return sha256(serialized).slice(0, 12);
+    return shortHash(serialized, 12);
   }
   let combined = "";
   for (const file of files) {
-    const filePath = join4(configDir, file);
+    const filePath = join5(configDir, file);
     try {
       const content = readFileSync3(filePath, "utf-8");
       combined += `\x00${file}\x00${content}`;
@@ -792,7 +746,7 @@ function computeEndpointConfigHash(customDir) {
       continue;
     }
   }
-  return sha256(combined).slice(0, 12);
+  return shortHash(combined, 12);
 }
 function getBuiltInEndpointConfigs() {
   return {
@@ -889,22 +843,26 @@ function getBuiltInEndpointConfigs() {
 }
 
 // src/services/endpoint-lock.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync as unlinkSync3 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir4 } from "os";
+import { readFileSync as readFileSync4, unlinkSync as unlinkSync3 } from "fs";
+import { join as join6 } from "path";
 function getLockFilePath(customDir) {
   if (customDir) {
-    return join5(customDir, ".endpoint-config.lock");
+    return join6(customDir, ".endpoint-config.lock");
   }
-  return join5(homedir4(), ".claude", "cc-api-statusline", ".endpoint-config.lock");
+  return join6(getConfigDir(), ".endpoint-config.lock");
 }
 function readEndpointLock(customDir) {
   const lockPath = getLockFilePath(customDir);
-  if (!existsSync6(lockPath)) {
-    return null;
+  let content;
+  try {
+    content = readFileSync4(lockPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
   }
   try {
-    const content = readFileSync4(lockPath, "utf-8");
     const data = JSON.parse(content);
     if (typeof data === "object" && data !== null && "hash" in data && "lockedAt" in data && typeof data.hash === "string" && typeof data.lockedAt === "string") {
       return {
@@ -929,6 +887,90 @@ function writeEndpointLock(hash, customDir) {
   });
 }
 
+// src/services/config.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+function getConfigPath(customPath) {
+  if (customPath) {
+    return customPath;
+  }
+  return join7(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) {
+  let maxWidth = config.display.maxWidth;
+  let pollIntervalSeconds = config.pollIntervalSeconds;
+  let pipedRequestTimeoutMs = config.pipedRequestTimeoutMs;
+  if (maxWidth < 20) {
+    logger.warn("display.maxWidth < 20, clamping to 20");
+    maxWidth = 20;
+  }
+  if (maxWidth > 100) {
+    logger.warn("display.maxWidth > 100, clamping to 100");
+    maxWidth = 100;
+  }
+  if (pollIntervalSeconds !== undefined && pollIntervalSeconds < 5) {
+    logger.warn("pollIntervalSeconds < 5, clamping to 5");
+    pollIntervalSeconds = 5;
+  }
+  if (pipedRequestTimeoutMs !== undefined && pipedRequestTimeoutMs < 100) {
+    logger.warn("pipedRequestTimeoutMs < 100, clamping to 100");
+    pipedRequestTimeoutMs = 100;
+  }
+  return {
+    ...config,
+    display: {
+      ...config.display,
+      maxWidth
+    },
+    pollIntervalSeconds,
+    pipedRequestTimeoutMs
+  };
+}
+function parseConfigContent(content, path) {
+  try {
+    const userConfig = JSON.parse(content);
+    const merged = deepMerge(DEFAULT_CONFIG, userConfig);
+    return validateConfig(merged);
+  } catch (err) {
+    logger.warn(`Could not load config from ${path}: ${err}`);
+    logger.warn("Using default configuration");
+    return DEFAULT_CONFIG;
+  }
+}
+function loadConfigWithHash(configPath) {
+  const path = getConfigPath(configPath);
+  let content;
+  try {
+    content = readFileSync5(path, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return { config: DEFAULT_CONFIG, configHash: shortHash("", 12) };
+    }
+    throw err;
+  }
+  return {
+    config: parseConfigContent(content, path),
+    configHash: shortHash(content, 12)
+  };
+}
+function serializableConfig(config) {
+  const { colors: _colors, ...rest } = config;
+  return rest;
+}
+
 // src/services/config-defaults.ts
 function getDefaultStyleConfig() {
   return DEFAULT_CONFIG;
@@ -948,26 +990,26 @@ function getDefaultCrsConfig() {
   return config;
 }
 function writeDefaultConfigs(customDir) {
-  const configDir = customDir || join6(homedir5(), ".claude", "cc-api-statusline");
-  const configPath = join6(configDir, "config.json");
+  const configDir = customDir || getConfigDir();
+  const configPath = join8(configDir, "config.json");
   const apiConfigDir = getEndpointConfigDir(customDir);
   ensureDir(configDir);
   ensureDir(apiConfigDir);
-  if (!existsSync7(configPath)) {
-    const styleConfig = getDefaultStyleConfig();
-    atomicWriteFile(configPath, JSON.stringify(styleConfig, null, 2), {
+  if (!existsSync4(configPath)) {
+    const styleConfigWithoutColors = serializableConfig(getDefaultStyleConfig());
+    atomicWriteFile(configPath, JSON.stringify(styleConfigWithoutColors, null, 2), {
       appendNewline: true
     });
   }
-  const sub2apiPath = join6(apiConfigDir, "sub2api.json");
-  if (!existsSync7(sub2apiPath)) {
+  const sub2apiPath = join8(apiConfigDir, "sub2api.json");
+  if (!existsSync4(sub2apiPath)) {
     const sub2apiConfig = getDefaultSub2apiConfig();
     atomicWriteFile(sub2apiPath, JSON.stringify(sub2apiConfig, null, 2), {
       appendNewline: true
     });
   }
-  const crsPath = join6(apiConfigDir, "crs.json");
-  if (!existsSync7(crsPath)) {
+  const crsPath = join8(apiConfigDir, "crs.json");
+  if (!existsSync4(crsPath)) {
     const crsConfig = getDefaultCrsConfig();
     atomicWriteFile(crsPath, JSON.stringify(crsConfig, null, 2), {
       appendNewline: true
@@ -977,10 +1019,10 @@ function writeDefaultConfigs(customDir) {
   writeEndpointLock(currentHash, customDir);
 }
 function needsConfigInit(customDir) {
-  const configDir = customDir || join6(homedir5(), ".claude", "cc-api-statusline");
-  const configPath = join6(configDir, "config.json");
+  const configDir = customDir || getConfigDir();
+  const configPath = join8(configDir, "config.json");
   const apiConfigDir = getEndpointConfigDir(customDir);
-  return !existsSync7(configPath) || !existsSync7(apiConfigDir);
+  return !existsSync4(configPath) || !existsSync4(apiConfigDir);
 }
 
 // src/providers/http.ts
@@ -1126,15 +1168,14 @@ async function probeHealth(baseUrl, timeoutMs = 1500) {
 }
 
 // src/services/cache.ts
-import { readFileSync as readFileSync5, existsSync as existsSync8, unlinkSync as unlinkSync4 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir6 } from "os";
+import { readFileSync as readFileSync6, unlinkSync as unlinkSync4 } from "fs";
+import { join as join9 } from "path";
 function getCacheDir() {
   const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
   if (override) {
     return override;
   }
-  return join7(homedir6(), ".claude", "cc-api-statusline");
+  return getConfigDir();
 }
 function ensureCacheDir() {
   const dir = getCacheDir();
@@ -1142,23 +1183,28 @@ function ensureCacheDir() {
 }
 function getCachePath(baseUrl) {
   const hash = shortHash(baseUrl, 12);
-  return join7(getCacheDir(), `cache-${hash}.json`);
+  return join9(getCacheDir(), `cache-${hash}.json`);
 }
 function readCache(baseUrl) {
   const path = getCachePath(baseUrl);
-  if (!existsSync8(path)) {
-    return null;
+  let content;
+  try {
+    content = readFileSync6(path, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
   }
   try {
-    const content = readFileSync5(path, "utf-8");
     const data = JSON.parse(content);
     if (!isCacheEntry(data)) {
-      console.warn(`Invalid cache structure at ${path}`);
+      logger.warn(`Invalid cache structure at ${path}`);
       return null;
     }
     return data;
-  } catch (error) {
-    console.warn(`Failed to read cache from ${path}: ${error}`);
+  } catch (err) {
+    logger.warn(`Failed to parse cache from ${path}: ${err}`);
     return null;
   }
 }
@@ -1169,7 +1215,7 @@ function writeCache(baseUrl, entry) {
     const content = JSON.stringify(entry, null, 2);
     atomicWriteFile(path, content);
   } catch (error) {
-    console.warn(`Failed to write cache to ${path}: ${error}`);
+    logger.warn(`Failed to write cache to ${path}: ${error}`);
   }
 }
 function isCacheValid(entry, currentEnv) {
@@ -1197,18 +1243,6 @@ function isCacheProviderValid(entry, currentProvider) {
 function isCacheRenderedLineUsable(entry, currentConfigHash) {
   return entry.configHash === currentConfigHash;
 }
-function computeConfigHash(configPath) {
-  if (!existsSync8(configPath)) {
-    return sha256("").slice(0, 12);
-  }
-  try {
-    const bytes = readFileSync5(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) {
@@ -1219,18 +1253,23 @@ function getEffectivePollInterval(config, envOverride) {
 }
 function getProviderDetectionCachePath(baseUrl) {
   const hash = shortHash(baseUrl, 12);
-  return join7(getCacheDir(), `provider-detect-${hash}.json`);
+  return join9(getCacheDir(), `provider-detect-${hash}.json`);
 }
 function readProviderDetectionCache(baseUrl) {
   const path = getProviderDetectionCachePath(baseUrl);
-  if (!existsSync8(path)) {
-    return null;
+  let content;
+  try {
+    content = readFileSync6(path, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
   }
   try {
-    const content = readFileSync5(path, "utf-8");
     const data = JSON.parse(content);
     if (!isProviderDetectionCacheEntry(data)) {
-      console.warn(`Invalid provider detection cache structure at ${path}`);
+      logger.warn(`Invalid provider detection cache structure at ${path}`);
       return null;
     }
     const detectedAt = new Date(data.detectedAt).getTime();
@@ -1244,8 +1283,8 @@ function readProviderDetectionCache(baseUrl) {
       return null;
     }
     return data;
-  } catch (error) {
-    console.warn(`Failed to read provider detection cache from ${path}: ${error}`);
+  } catch (err) {
+    logger.warn(`Failed to parse provider detection cache from ${path}: ${err}`);
     return null;
   }
 }
@@ -1256,13 +1295,15 @@ function writeProviderDetectionCache(baseUrl, entry) {
     const content = JSON.stringify(entry, null, 2);
     atomicWriteFile(path, content);
   } catch (error) {
-    console.warn(`Failed to write provider detection cache to ${path}: ${error}`);
+    logger.warn(`Failed to write provider detection cache to ${path}: ${error}`);
   }
 }
 
 // src/providers/autodetect.ts
 var detectionCache = new Map;
-function detectProviderFromUrlPattern(baseUrl, endpointConfigs = {}) {
+function detectProviderFromUrlPattern(baseUrl, endpointConfigs = {}, options = {}) {
+  const includeBuiltInPatterns = options.includeBuiltInPatterns ?? true;
+  const fallbackProvider = Object.prototype.hasOwnProperty.call(options, "fallbackProvider") ? options.fallbackProvider ?? null : "sub2api";
   const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
   for (const [providerId, config] of Object.entries(endpointConfigs)) {
     const urlPatterns = config.detection?.urlPatterns;
@@ -1275,10 +1316,10 @@ function detectProviderFromUrlPattern(baseUrl, endpointConfigs = {}) {
       }
     }
   }
-  if (normalizedUrl.includes("/apistats") || normalizedUrl.includes("/api/user-stats")) {
+  if (includeBuiltInPatterns && (normalizedUrl.includes("/apistats") || normalizedUrl.includes("/api/user-stats"))) {
     return "claude-relay-service";
   }
-  return "sub2api";
+  return fallbackProvider;
 }
 async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {}, probeTimeoutMs = 1500) {
   if (providerOverride) {
@@ -1302,19 +1343,14 @@ async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {},
     });
     return diskCached.provider;
   }
-  for (const [providerId, config] of Object.entries(endpointConfigs)) {
-    const urlPatterns = config.detection?.urlPatterns;
-    if (urlPatterns && urlPatterns.length > 0) {
-      const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
-      for (const pattern of urlPatterns) {
-        const normalizedPattern = pattern.toLowerCase();
-        if (normalizedUrl.includes(normalizedPattern)) {
-          logger.debug("Provider detected via endpoint URL pattern", { provider: providerId, pattern });
-          cacheProviderDetection(baseUrl, providerId, "url-pattern");
-          return providerId;
-        }
-      }
-    }
+  const endpointPatternProvider = detectProviderFromUrlPattern(baseUrl, endpointConfigs, {
+    includeBuiltInPatterns: false,
+    fallbackProvider: null
+  });
+  if (endpointPatternProvider) {
+    logger.debug("Provider detected via endpoint URL pattern", { provider: endpointPatternProvider });
+    cacheProviderDetection(baseUrl, endpointPatternProvider, "url-pattern");
+    return endpointPatternProvider;
   }
   logger.debug("Attempting health probe", { baseUrl, timeoutMs: probeTimeoutMs });
   const probedProvider = await probeHealth(baseUrl, probeTimeoutMs);
@@ -1324,6 +1360,11 @@ async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {},
     return probedProvider;
   }
   const patternProvider = detectProviderFromUrlPattern(baseUrl, {});
+  if (!patternProvider) {
+    logger.debug("Provider URL pattern detection had no match, defaulting to sub2api");
+    cacheProviderDetection(baseUrl, "sub2api", "url-pattern");
+    return "sub2api";
+  }
   logger.debug("Provider detected via built-in URL pattern", { provider: patternProvider });
   cacheProviderDetection(baseUrl, patternProvider, "url-pattern");
   return patternProvider;
@@ -1347,8 +1388,8 @@ function clearDetectionCache() {
 }
 
 // src/cli/commands.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
+import { join as join10 } from "path";
 function handleInstall(args) {
   const existing = getExistingStatusLine();
   if (existing && !args.force) {
@@ -1391,11 +1432,11 @@ function handleApplyConfig() {
   console.log("✓ Provider detection cache cleared");
   const cacheDir = getCacheDir();
   let failCount = 0;
-  if (existsSync9(cacheDir)) {
+  if (existsSync5(cacheDir)) {
     const files = readdirSync3(cacheDir).filter((f) => f.startsWith("cache-") && f.endsWith(".json"));
     for (const file of files) {
       try {
-        const filePath = join8(cacheDir, file);
+        const filePath = join10(cacheDir, file);
         unlinkSync5(filePath);
       } catch {
         failCount++;
@@ -1415,7 +1456,7 @@ function handleApplyConfig() {
   console.log("");
   console.log("Config files:");
   const apiConfigDir = getEndpointConfigDir();
-  if (existsSync9(apiConfigDir)) {
+  if (existsSync5(apiConfigDir)) {
     const configFiles = readdirSync3(apiConfigDir).filter((f) => f.endsWith(".json"));
     for (const file of configFiles) {
       console.log(`  - ${apiConfigDir}/${file}`);
@@ -1423,83 +1464,10 @@ function handleApplyConfig() {
   }
   process.exit(0);
 }
-// src/services/config.ts
-import { readFileSync as readFileSync6, existsSync as existsSync10 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir7 } from "os";
-function getConfigDir() {
-  return join9(homedir7(), ".claude", "cc-api-statusline");
-}
-function getConfigPath(customPath) {
-  if (customPath) {
-    return customPath;
-  }
-  return join9(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) {
-  let maxWidth = config.display.maxWidth;
-  let pollIntervalSeconds = config.pollIntervalSeconds;
-  let pipedRequestTimeoutMs = config.pipedRequestTimeoutMs;
-  if (maxWidth < 20) {
-    console.warn("Warning: display.maxWidth < 20, clamping to 20");
-    maxWidth = 20;
-  }
-  if (maxWidth > 100) {
-    console.warn("Warning: display.maxWidth > 100, clamping to 100");
-    maxWidth = 100;
-  }
-  if (pollIntervalSeconds !== undefined && pollIntervalSeconds < 5) {
-    console.warn("Warning: pollIntervalSeconds < 5, clamping to 5");
-    pollIntervalSeconds = 5;
-  }
-  if (pipedRequestTimeoutMs !== undefined && pipedRequestTimeoutMs < 100) {
-    console.warn("Warning: pipedRequestTimeoutMs < 100, clamping to 100");
-    pipedRequestTimeoutMs = 100;
-  }
-  return {
-    ...config,
-    display: {
-      ...config.display,
-      maxWidth
-    },
-    pollIntervalSeconds,
-    pipedRequestTimeoutMs
-  };
-}
-function loadConfig(configPath) {
-  const path = getConfigPath(configPath);
-  if (!existsSync10(path)) {
-    return DEFAULT_CONFIG;
-  }
-  try {
-    const content = readFileSync6(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/services/user-agent.ts
 import { execSync as execSync2 } from "child_process";
-import { join as join10 } from "path";
-import { homedir as homedir8 } from "os";
+import { join as join11 } from "path";
+import { homedir as homedir3 } from "os";
 var FALLBACK_UA = "claude-cli/2.1.56 (external, cli)";
 function resolveUserAgent(config) {
   if (!config) {
@@ -1526,10 +1494,10 @@ function detectClaudeVersion() {
     if (!process.env["CLAUDECODE"]) {
       return null;
     }
-    const claudePath = join10(homedir8(), ".claude", "bin", "claude");
+    const claudePath = join11(homedir3(), ".claude", "bin", "claude");
     const result = execSync2(`"${claudePath}" --version`, {
       encoding: "utf-8",
-      timeout: 1000,
+      timeout: 100,
       stdio: ["ignore", "pipe", "ignore"]
     });
     const match = result.match(/(\d+\.\d+\.\d+)/);
@@ -1844,19 +1812,17 @@ function mapResponseToUsage(responseData, mapping, endpointConfig) {
       remainingSeconds: extractNumber(responseData, mapping["rateLimit.remainingSeconds"]) ?? 0
     };
   })();
-  const resetsAt = (() => {
-    const times = [];
-    if (daily?.resetsAt)
-      times.push(daily.resetsAt);
-    if (weekly?.resetsAt)
-      times.push(weekly.resetsAt);
-    if (monthly?.resetsAt)
-      times.push(monthly.resetsAt);
-    if (times.length === 0)
-      return null;
-    const sorted = [...times].sort();
-    return sorted[0] ?? null;
-  })();
+  const resetsAt = computeSoonestReset({
+    ...base,
+    resetSemantics: billingMode === "balance" ? "expiry" : "end-of-day",
+    balance,
+    daily,
+    weekly,
+    monthly,
+    tokenStats,
+    rateLimit,
+    resetsAt: null
+  });
   return {
     ...base,
     resetSemantics: billingMode === "balance" ? "expiry" : "end-of-day",
@@ -1871,7 +1837,7 @@ function mapResponseToUsage(responseData, mapping, endpointConfig) {
 }
 
 // src/providers/endpoint-fetch.ts
-function validateEndpointConfig2(config) {
+function validateEndpointConfigSemantics(config) {
   if (!config.provider)
     return "Endpoint config missing required field: provider";
   if (!config.endpoint?.path)
@@ -1894,7 +1860,7 @@ function validateEndpointConfig2(config) {
   return null;
 }
 async function fetchEndpoint(baseUrl, token, appConfig, endpointConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const validationError = validateEndpointConfig2(endpointConfig);
+  const validationError = validateEndpointConfigSemantics(endpointConfig);
   if (validationError) {
     throw new Error(`Invalid endpoint config: ${validationError}`);
   }
@@ -2099,6 +2065,9 @@ function hexToRgb(hex) {
 function dimText(text) {
   return `${ANSI_DIM}${text}${ANSI_RESET}`;
 }
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
 function resolveColor(colorName, usagePercent, config) {
   const effectiveColor = colorName ?? "auto";
   if (effectiveColor.startsWith("#") || ANSI_COLORS[effectiveColor.toLowerCase()]) {
@@ -2493,46 +2462,49 @@ function formatCompactNumber(n) {
 
 // src/renderer/component.ts
 function renderComponent(componentId, data, componentConfig, globalConfig, renderContext) {
-  const effectiveLayout = componentConfig.layout ?? globalConfig.display.layout;
-  const effectiveDisplayMode = resolveEffectiveDisplayMode(componentConfig.displayMode ?? globalConfig.display.displayMode, renderContext);
-  const effectiveProgressStyle = resolveEffectiveProgressStyle(componentConfig.progressStyle ?? globalConfig.display.progressStyle, renderContext);
-  const effectiveBarSize = componentConfig.barSize ?? globalConfig.display.barSize;
-  const effectiveBarStyle = componentConfig.barStyle ?? globalConfig.display.barStyle;
-  const clockFormat = globalConfig.display.clockFormat;
+  const options = {
+    layout: componentConfig.layout ?? globalConfig.display.layout,
+    displayMode: resolveEffectiveDisplayMode(componentConfig.displayMode ?? globalConfig.display.displayMode, renderContext),
+    progressStyle: resolveEffectiveProgressStyle(componentConfig.progressStyle ?? globalConfig.display.progressStyle, renderContext),
+    barSize: componentConfig.barSize ?? globalConfig.display.barSize,
+    barStyle: componentConfig.barStyle ?? globalConfig.display.barStyle,
+    clockFormat: globalConfig.display.clockFormat
+  };
   switch (componentId) {
     case "daily":
-      return renderQuotaComponent("daily", data.daily, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "weekly":
-      return renderQuotaComponent("weekly", data.weekly, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "monthly":
-      return renderQuotaComponent("monthly", data.monthly, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
+      return renderQuotaComponent(componentId, data[componentId], options, componentConfig, globalConfig, renderContext);
     case "balance":
-      return renderBalanceComponent(data.balance, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, renderContext);
+      return renderBalanceComponent(data.balance, options, componentConfig, globalConfig, renderContext);
     case "tokens":
-      return renderTokensComponent(data.tokenStats, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig, renderContext);
+      return renderTokensComponent(data.tokenStats, options, componentConfig, globalConfig, renderContext);
     case "rateLimit":
-      return renderRateLimitComponent(data.rateLimit, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, renderContext);
+      return renderRateLimitComponent(data.rateLimit, options, componentConfig, globalConfig, renderContext);
     case "plan":
-      return renderPlanComponent(data.planName, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig, renderContext);
+      return renderPlanComponent(data.planName, options, componentConfig, globalConfig, renderContext);
     default:
       return null;
   }
 }
-function renderQuotaComponent(componentId, quota, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, clockFormat, renderContext) {
+function renderQuotaComponent(componentId, quota, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!quota)
     return null;
   const usagePercent = calculateUsagePercent(quota.used, quota.limit);
   const label = renderLabel(componentId, displayMode, componentConfig, quota.qualifier);
+  const showPercentage = componentConfig.percentage !== false;
   const barColor = resolvePartColor("bar", usagePercent, componentConfig, globalConfig);
-  const valueColor = resolvePartColor("value", usagePercent, componentConfig, globalConfig);
+  const valueColor = showPercentage ? resolvePartColor("value", usagePercent, componentConfig, globalConfig) : null;
   const labelColor = resolvePartColor("label", usagePercent, componentConfig, globalConfig);
   const countdownColor = resolvePartColor("countdown", usagePercent, componentConfig, globalConfig);
   const progress = renderProgress(progressStyle, usagePercent, barSize, barStyle, barColor, null, renderContext);
-  const value = ansiColor(`${Math.round(usagePercent)}%`, valueColor, renderContext);
+  const value = showPercentage ? ansiColor(`${Math.round(usagePercent)}%`, valueColor, renderContext) : "";
   const countdown = renderSecondaryDisplay(quota.resetsAt, quota, componentConfig.countdown, countdownColor, clockFormat, renderContext);
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderBalanceComponent(balance, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, renderContext) {
+function renderBalanceComponent(balance, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!balance)
     return null;
   const isUnlimited = balance.remaining === -1;
@@ -2551,7 +2523,8 @@ function renderBalanceComponent(balance, layout, displayMode, progressStyle, bar
   const countdown = "";
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderTokensComponent(tokenStats, layout, displayMode, componentConfig, globalConfig, renderContext) {
+function renderTokensComponent(tokenStats, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!tokenStats)
     return null;
   const stats = tokenStats.total ?? tokenStats.today;
@@ -2567,7 +2540,8 @@ function renderTokensComponent(tokenStats, layout, displayMode, componentConfig,
   const countdown = "";
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderRateLimitComponent(rateLimit, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, renderContext) {
+function renderRateLimitComponent(rateLimit, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!rateLimit)
     return null;
   let usagePercent = null;
@@ -2584,7 +2558,8 @@ function renderRateLimitComponent(rateLimit, layout, displayMode, progressStyle,
   const countdown = "";
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderPlanComponent(planName, layout, displayMode, componentConfig, globalConfig, renderContext) {
+function renderPlanComponent(planName, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (displayMode === "hidden")
     return null;
   const labelColor = resolvePartColor("label", null, componentConfig, globalConfig);
@@ -2698,21 +2673,25 @@ function assembleComponent(layout, label, labelColor, progress, value, countdown
   if (layout === "percent-first") {
     if (coloredLabel)
       parts.push(coloredLabel);
-    parts.push(value);
+    if (value)
+      parts.push(value);
     if (progress)
       parts.push(progress);
-    if (countdown)
-      parts.push(countdown);
   } else {
     if (coloredLabel)
       parts.push(coloredLabel);
     if (progress)
       parts.push(progress);
-    parts.push(value);
-    if (countdown)
-      parts.push(countdown);
+    if (value)
+      parts.push(value);
   }
-  return parts.filter((p) => p).join(" ").replace(/ (\x1b\[[0-9;]*m)? ([·•])/g, "$1 $2");
+  if (countdown && parts.length > 0) {
+    const idx = parts.length - 1;
+    parts[idx] = (parts[idx] ?? "") + countdown;
+  } else if (countdown) {
+    parts.push(countdown);
+  }
+  return parts.join(" ");
 }
 function calculateUsagePercent(used, limit) {
   if (limit === null)
@@ -2749,8 +2728,7 @@ function computeMaxWidth(termWidth, maxWidthPct) {
   return Math.floor(termWidth * pct / 100);
 }
 function visibleLength(text) {
-  const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
-  return stripped.length;
+  return stripAnsi(text).length;
 }
 function ansiAwareTruncate(text, maxWidth) {
   const visible = visibleLength(text);
@@ -2797,8 +2775,8 @@ var COMPONENT_DROP_PRIORITY = [
 // src/renderer/divider.ts
 function renderDivider(divider) {
   const text = divider.text ?? "|";
-  const padding = divider.padding ?? 1;
-  const pad = " ".repeat(padding);
+  const margin = divider.margin ?? 1;
+  const pad = " ".repeat(margin);
   const padded = `${pad}${text}${pad}`;
   return ansiColor(padded, divider.color ?? "#555753");
 }
@@ -2890,63 +2868,46 @@ function renderStatusline(data, config, errorState, cacheAge, isPiped = false) {
       currentWidth = calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge);
     }
   }
-  const renderedComponents = [];
-  for (const componentId of componentOrder) {
-    if (activeComponents.has(componentId)) {
-      const rendered = componentMap.get(componentId);
-      if (rendered)
-        renderedComponents.push(rendered);
-    }
-  }
-  let statusline = renderedComponents.join(separator);
-  if (errorState) {
-    if (isTransitionState(errorState)) {
-      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);
-      statusline = hasCache ? `${statusline} ${errorIndicator}` : errorIndicator;
-    }
-  }
+  let statusline = assembleStatuslineString(componentOrder, componentMap, activeComponents, separator, errorState, data, cacheAge);
   const termWidth = getTerminalWidth();
   const maxW = computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
   statusline = ansiAwareTruncate(statusline, maxW);
   return statusline;
 }
 function computeSeparator(config) {
-  const dividerConfig = config.components.divider;
+  const dividerConfig = config.display.divider;
   if (dividerConfig === false)
     return "";
-  if (typeof dividerConfig === "object")
-    return renderDivider(dividerConfig);
-  return config.display.separator ?? " | ";
+  return renderDivider(dividerConfig ?? DEFAULT_DIVIDER_CONFIG);
 }
 function maxWidth(config) {
   const termWidth = getTerminalWidth();
   return computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
 }
-function calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge) {
-  const components = [];
+function assembleStatuslineString(componentOrder, componentMap, activeComponents, separator, errorState, data, cacheAge) {
+  const rendered = [];
   for (const id of componentOrder) {
     if (activeComponents.has(id)) {
-      const rendered = componentMap.get(id);
-      if (rendered)
-        components.push(rendered);
+      const r = componentMap.get(id);
+      if (r)
+        rendered.push(r);
     }
   }
-  let statusline = components.join(separator);
+  let statusline = rendered.join(separator);
   if (errorState) {
     if (isTransitionState(errorState)) {
       statusline = renderError(errorState, "with-cache", data.provider, undefined, cacheAge);
     } else {
-      const hasCache = components.length > 0;
+      const hasCache = rendered.length > 0;
       const errorMode = hasCache ? "with-cache" : "without-cache";
       const errorIndicator = renderError(errorState, errorMode, data.provider, undefined, cacheAge);
       statusline = hasCache ? `${statusline} ${errorIndicator}` : errorIndicator;
     }
   }
-  return visibleLength(statusline);
+  return statusline;
+}
+function calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge) {
+  return visibleLength(assembleStatuslineString(componentOrder, componentMap, activeComponents, separator, errorState, data, cacheAge));
 }
 function getComponentOrder(config) {
   const explicitOrder = [];
@@ -3094,11 +3055,11 @@ async function executeCycle(ctx) {
   }
 }
 // src/services/cache-gc.ts
-import { readdirSync as readdirSync4, statSync as statSync2, unlinkSync as unlinkSync6, existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync4, statSync as statSync2, unlinkSync as unlinkSync6, existsSync as existsSync6 } from "fs";
+import { join as join12 } from "path";
 function runCacheGC(cacheDir) {
   try {
-    if (!existsSync11(cacheDir)) {
+    if (!existsSync6(cacheDir)) {
       logger.debug("GC: Cache directory does not exist, skipping", { cacheDir });
       return;
     }
@@ -3109,7 +3070,7 @@ function runCacheGC(cacheDir) {
     const tmpFiles = [];
     for (const file of files) {
       try {
-        const filePath = join11(cacheDir, file);
+        const filePath = join12(cacheDir, file);
         const stats = statSync2(filePath);
         const mtime = stats.mtimeMs;
         if (file.startsWith("cache-") && file.endsWith(".json")) {
@@ -3129,7 +3090,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_MAX_AGE_MS) {
         try {
-          unlinkSync6(join11(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted old cache file", { file: file.name, ageDays: Math.floor(age / (24 * 60 * 60 * 1000)) });
         } catch (error) {
@@ -3141,7 +3102,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_MAX_AGE_MS) {
         try {
-          unlinkSync6(join11(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted old provider-detect file", { file: file.name, ageDays: Math.floor(age / (24 * 60 * 60 * 1000)) });
         } catch (error) {
@@ -3153,7 +3114,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_ORPHAN_TMP_AGE_MS) {
         try {
-          unlinkSync6(join11(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted orphaned tmp file", { file: file.name, ageMinutes: Math.floor(age / (60 * 1000)) });
         } catch (error) {
@@ -3170,7 +3131,7 @@ function runCacheGC(cacheDir) {
       const toDelete = remainingCacheFiles.slice(0, remainingCacheFiles.length - GC_MAX_CACHE_FILES);
       for (const file of toDelete) {
         try {
-          unlinkSync6(join11(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted cache file (count limit)", { file: file.name });
         } catch (error) {
@@ -3192,6 +3153,11 @@ class StatuslineError extends Error {
     this.errorType = errorType;
   }
 }
+function safeStdoutWrite(data) {
+  try {
+    process.stdout["write"](data);
+  } catch {}
+}
 function readAndValidateEnv() {
   const env = readCurrentEnv();
   logger.debug("Environment loaded", {
@@ -3206,7 +3172,7 @@ function readAndValidateEnv() {
   }
   const { baseUrl } = env;
   if (!baseUrl) {
-    process.exit(1);
+    process.exit(0);
   }
   return { env, baseUrl };
 }
@@ -3216,13 +3182,6 @@ function ensureDefaultConfigs() {
     writeDefaultConfigs();
   }
 }
-function loadConfigWithHash(configPath) {
-  const config = loadConfig(configPath);
-  const resolvedPath = getConfigPath(configPath);
-  const configHash = computeConfigHash(resolvedPath);
-  logger.debug("Config loaded", { configPath: resolvedPath, configHash });
-  return { config, configHash };
-}
 function loadEndpointConfigsWithHash() {
   const endpointConfigs = loadEndpointConfigs();
   const endpointConfigHash = computeEndpointConfigHash();
@@ -3330,7 +3289,7 @@ async function executePipedMode(args) {
       logger.error("Watchdog timeout - forcing clean exit", { watchdogMs });
       const fallback = dimText("⟳ Refreshing...");
       const formatted = formatOutput(fallback, isPiped);
-      process.stdout.write(formatted);
+      safeStdoutWrite(formatted);
       process.exit(0);
     }, watchdogMs).unref();
   }
@@ -3343,7 +3302,7 @@ async function executePipedMode(args) {
     const errorType = error instanceof StatuslineError ? error.errorType : "network-error";
     const errorOutput = renderError(errorType, "without-cache");
     const formattedOutput2 = formatOutput(errorOutput, isPiped);
-    process.stdout.write(formattedOutput2);
+    safeStdoutWrite(formattedOutput2);
     logger.debug("=== cc-api-statusline execution completed ===");
     process.exit(0);
   }
@@ -3358,7 +3317,7 @@ async function executePipedMode(args) {
     logger.error("Execution cycle failed", { error: String(error) });
     const errorOutput = renderError("network-error", "without-cache");
     const formattedOutput2 = formatOutput(errorOutput, isPiped);
-    process.stdout.write(formattedOutput2);
+    safeStdoutWrite(formattedOutput2);
     logger.debug("=== cc-api-statusline execution completed ===");
     process.exit(0);
   }
@@ -3370,7 +3329,7 @@ async function executePipedMode(args) {
     cacheUpdate: !!result.cacheUpdate
   });
   const formattedOutput = formatOutput(result.output, isPiped);
-  process.stdout.write(formattedOutput);
+  safeStdoutWrite(formattedOutput);
   if (result.cacheUpdate) {
     writeCache(baseUrl, result.cacheUpdate);
     logger.debug("Cache written", { baseUrl });
@@ -3428,6 +3387,5 @@ process.on("uncaughtException", (error) => {
 });
 main().catch((error) => {
   logger.error("Unhandled error in main", { error: String(error) });
-  console.error(`Fatal error: ${error}`);
-  process.exit(1);
+  process.exit(0);
 });