cc-api-statusline 0.2.1 → 0.2.2

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.1",
+  version: "0.2.2",
   description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
   type: "module",
   bin: {
@@ -68,6 +68,7 @@ function parseArgs() {
   let once = false;
   let install = false;
   let uninstall = false;
+  let applyConfig = false;
   let force = false;
   let configPath;
   let runner;
@@ -83,6 +84,8 @@ function parseArgs() {
       install = true;
     } else if (arg === "--uninstall") {
       uninstall = true;
+    } else if (arg === "--apply-config") {
+      applyConfig = true;
     } else if (arg === "--force") {
       force = true;
     } else if (arg === "--config" && i + 1 < args.length) {
@@ -96,7 +99,7 @@ function parseArgs() {
       i++;
     }
   }
-  return { help, version, once, install, uninstall, force, configPath, runner };
+  return { help, version, once, install, uninstall, applyConfig, force, configPath, runner };
 }
 function showHelp() {
   console.log(`
@@ -110,8 +113,9 @@ Options:
   --version, -v      Show version
   --once             Fetch once and exit (no polling)
   --config <path>    Use custom config file
-  --install          Register as Claude Code statusline widget
+  --install          Register as Claude Code statusline widget and create default configs
   --uninstall        Remove statusline widget registration
+  --apply-config     Apply endpoint config changes (updates lock file, clears caches)
   --runner <runner>  Package runner: npx or bunx (default: auto-detect)
   --force            Force overwrite existing statusline configuration
 
@@ -321,38 +325,10 @@ function uninstallStatusLine() {
   }
 }
 
-// src/cli/commands.ts
-function handleInstall(args) {
-  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);
-}
-function handleUninstall() {
-  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);
-}
-// src/services/cache.ts
-import { readFileSync as readFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+// src/services/config-defaults.ts
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { existsSync as existsSync7 } from "fs";
 
 // src/types/normalized-usage.ts
 function createEmptyNormalizedUsage(provider, billingMode, planName) {
@@ -411,22 +387,68 @@ var DEFAULT_CONFIG = {
   colors: {
     auto: {
       tiers: [
-        { color: "cool", maxPercent: 30 },
-        { color: "comfortable", maxPercent: 65 },
-        { color: "warm", maxPercent: 80 },
-        { color: "hot", maxPercent: 90 },
-        { color: "critical", maxPercent: 100 }
+        { 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: {
-      low: "cyan",
-      medium: "blue",
-      high: "magenta",
-      lowThreshold: 50,
-      highThreshold: 80
+      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 }
+      ]
     }
   },
-  customProviders: {},
   pollIntervalSeconds: 30,
   pipedRequestTimeoutMs: 800
 };
@@ -493,12 +515,12 @@ var DEFAULT_COMPONENT_ORDER = [
   "plan"
 ];
 // src/types/cache.ts
-var CACHE_VERSION = 1;
+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["data"] === "object" && c["data"] !== null && typeof c["renderedLine"] === "string" && typeof c["fetchedAt"] === "string" && typeof c["ttlSeconds"] === "number" && (c["errorState"] === null || typeof c["errorState"] === "object");
+  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) {
@@ -507,209 +529,458 @@ function isProviderDetectionCacheEntry(value) {
   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/cache.ts
-function getCacheDir() {
-  const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
-  if (override) {
-    return override;
-  }
-  return join2(homedir2(), ".claude", "cc-api-statusline");
+// 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 ensureCacheDir() {
-  const dir = getCacheDir();
-  ensureDir(dir);
+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 getCachePath(baseUrl) {
-  const hash = shortHash(baseUrl, 12);
-  return join2(getCacheDir(), `cache-${hash}.json`);
+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);
 }
-function readCache(baseUrl) {
-  const path = getCachePath(baseUrl);
-  if (!existsSync5(path)) {
-    return null;
+
+// 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);
+    }
   }
-  try {
-    const content = readFileSync3(path, "utf-8");
-    const data = JSON.parse(content);
-    if (!isCacheEntry(data)) {
-      console.warn(`Invalid cache structure at ${path}`);
-      return null;
+  ensureLogDir() {
+    try {
+      const dir = dirname3(this.logPath);
+      ensureDir(dir);
+    } catch {
+      this.enabled = false;
     }
-    return data;
-  } catch (error) {
-    console.warn(`Failed to read cache from ${path}: ${error}`);
-    return null;
   }
-}
-function writeCache(baseUrl, entry) {
-  const path = getCachePath(baseUrl);
-  try {
-    ensureCacheDir();
-    const content = JSON.stringify(entry, null, 2);
-    atomicWriteFile(path, content);
-  } catch (error) {
-    console.warn(`Failed to write cache to ${path}: ${error}`);
+  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)}`;
   }
-}
-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;
+  format(level, message, data) {
+    const timestamp = this.formatLocalTimestamp();
+    const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+    return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}
+`;
   }
-  if (entry.baseUrl !== currentEnv.baseUrl) {
-    return false;
+  write(level, message, data) {
+    if (!this.enabled) {
+      return;
+    }
+    try {
+      const entry = this.format(level, message, data);
+      appendFileSync(this.logPath, entry, { encoding: "utf-8" });
+    } catch {}
   }
-  if (entry.version !== CACHE_VERSION) {
-    return false;
+  debug(message, data) {
+    this.write("debug", message, data);
   }
-  if (entry.tokenHash !== currentEnv.tokenHash) {
-    return false;
+  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;
   }
-  return true;
 }
-function isCacheProviderValid(entry, currentProvider) {
-  return entry.provider === currentProvider;
+var logger = new Logger;
+
+// src/services/endpoint-config.ts
+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");
+}
+function loadEndpointConfigs(customDir) {
+  const configDir = getEndpointConfigDir(customDir);
+  if (!existsSync5(configDir)) {
+    return getBuiltInEndpointConfigs();
+  }
+  const registry = {};
+  const files = readdirSync2(configDir).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) {
+    return getBuiltInEndpointConfigs();
+  }
+  for (const file of files) {
+    const filePath = join4(configDir, file);
+    try {
+      const config = loadEndpointConfigFile(filePath);
+      registry[config.provider] = config;
+    } catch (error) {
+      logger.error(`Failed to load endpoint config ${file}`, { error: String(error) });
+    }
+  }
+  if (Object.keys(registry).length === 0) {
+    return getBuiltInEndpointConfigs();
+  }
+  return registry;
 }
-function isCacheRenderedLineUsable(entry, currentConfigHash) {
-  return entry.configHash === currentConfigHash;
+function loadEndpointConfigFile(filePath) {
+  const content = readFileSync3(filePath, "utf-8");
+  const data = JSON.parse(content);
+  validateEndpointConfig(data, filePath);
+  return data;
 }
-function computeConfigHash(configPath) {
-  if (!existsSync5(configPath)) {
-    return sha256("").slice(0, 12);
+function validateEndpointConfig(data, filename) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error(`${filename}: Config must be an object`);
   }
-  try {
-    const bytes = readFileSync3(configPath);
-    return shortHash(bytes.toString("utf-8"), 12);
-  } catch (error) {
-    console.warn(`Failed to read config for hash: ${error}`);
-    return sha256("").slice(0, 12);
+  const config = data;
+  if (typeof config.provider !== "string" || !config.provider) {
+    throw new Error(`${filename}: Missing or invalid 'provider' field`);
+  }
+  if (typeof config.endpoint !== "object" || config.endpoint === null) {
+    throw new Error(`${filename}: Missing or invalid 'endpoint' field`);
+  }
+  const endpoint = config.endpoint;
+  if (typeof endpoint.path !== "string" || !endpoint.path) {
+    throw new Error(`${filename}: Missing or invalid 'endpoint.path' field`);
+  }
+  if (endpoint.method !== "GET" && endpoint.method !== "POST") {
+    throw new Error(`${filename}: Invalid 'endpoint.method' (must be GET or POST)`);
+  }
+  if (typeof config.auth !== "object" || config.auth === null) {
+    throw new Error(`${filename}: Missing or invalid 'auth' field`);
+  }
+  const auth = config.auth;
+  if (!["bearer-header", "body-key", "custom-header"].includes(auth.type)) {
+    throw new Error(`${filename}: Invalid 'auth.type' (must be bearer-header, body-key, or custom-header)`);
+  }
+  if (typeof config.responseMapping !== "object" || config.responseMapping === null) {
+    throw new Error(`${filename}: Missing or invalid 'responseMapping' field`);
+  }
+  const mapping = config.responseMapping;
+  for (const [key, val] of Object.entries(mapping)) {
+    if (val !== undefined && typeof val !== "string") {
+      throw new Error(`${filename}: responseMapping.${key} must be a string`);
+    }
+  }
+  if (config.displayName !== undefined && typeof config.displayName !== "string") {
+    throw new Error(`${filename}: Invalid 'displayName' field (must be string)`);
+  }
+  if (config.defaults !== undefined && typeof config.defaults !== "object") {
+    throw new Error(`${filename}: Invalid 'defaults' field (must be object)`);
+  }
+  if (config.detection !== undefined && typeof config.detection !== "object") {
+    throw new Error(`${filename}: Invalid 'detection' field (must be object)`);
   }
 }
-var DEFAULT_POLL_INTERVAL_SECONDS = 30;
-function getEffectivePollInterval(config, envOverride) {
-  if (envOverride !== null) {
-    return Math.max(5, envOverride);
+function computeEndpointConfigHash(customDir) {
+  const configDir = getEndpointConfigDir(customDir);
+  if (!existsSync5(configDir)) {
+    const builtIn = getBuiltInEndpointConfigs();
+    const serialized = JSON.stringify(builtIn, Object.keys(builtIn).sort());
+    return sha256(serialized).slice(0, 12);
   }
-  const fromConfig = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
-  return Math.max(5, fromConfig);
+  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);
+  }
+  let combined = "";
+  for (const file of files) {
+    const filePath = join4(configDir, file);
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      combined += `\x00${file}\x00${content}`;
+    } catch {
+      continue;
+    }
+  }
+  return sha256(combined).slice(0, 12);
 }
-function getProviderDetectionCachePath(baseUrl) {
-  const hash = shortHash(baseUrl, 12);
-  return join2(getCacheDir(), `provider-detect-${hash}.json`);
+function getBuiltInEndpointConfigs() {
+  return {
+    sub2api: {
+      provider: "sub2api",
+      displayName: "sub2api",
+      endpoint: {
+        path: "/v1/usage",
+        method: "GET"
+      },
+      auth: {
+        type: "bearer-header"
+      },
+      defaults: {
+        unit: "USD",
+        planName: "Unknown"
+      },
+      detection: {
+        healthMatch: { status: "ok" }
+      },
+      responseMapping: {
+        billingMode: "subscription",
+        planName: "$.planName",
+        "balance.remaining": "$.remaining",
+        "balance.unit": "$.unit",
+        "daily.used": "$.subscription.daily_usage_usd",
+        "daily.limit": "$.subscription.daily_limit_usd",
+        "weekly.used": "$.subscription.weekly_usage_usd",
+        "weekly.limit": "$.subscription.weekly_limit_usd",
+        "monthly.used": "$.subscription.monthly_usage_usd",
+        "monthly.limit": "$.subscription.monthly_limit_usd",
+        "tokenStats.today.requests": "$.usage.today.requests",
+        "tokenStats.today.inputTokens": "$.usage.today.input_tokens",
+        "tokenStats.today.outputTokens": "$.usage.today.output_tokens",
+        "tokenStats.today.cacheCreationTokens": "$.usage.today.cache_creation_tokens",
+        "tokenStats.today.cacheReadTokens": "$.usage.today.cache_read_tokens",
+        "tokenStats.today.totalTokens": "$.usage.today.total_tokens",
+        "tokenStats.today.cost": "$.usage.today.cost",
+        "tokenStats.total.requests": "$.usage.total.requests",
+        "tokenStats.total.inputTokens": "$.usage.total.input_tokens",
+        "tokenStats.total.outputTokens": "$.usage.total.output_tokens",
+        "tokenStats.total.totalTokens": "$.usage.total.total_tokens",
+        "tokenStats.total.cost": "$.usage.total.cost",
+        "tokenStats.rpm": "$.usage.rpm",
+        "tokenStats.tpm": "$.usage.tpm"
+      }
+    },
+    "claude-relay-service": {
+      provider: "claude-relay-service",
+      displayName: "CRS",
+      endpoint: {
+        path: "/apiStats/api/user-stats",
+        method: "POST",
+        contentType: "application/json"
+      },
+      auth: {
+        type: "body-key",
+        bodyField: "apiKey"
+      },
+      defaults: {
+        billingMode: "subscription",
+        planName: "API Key",
+        resetSemantics: "rolling-window"
+      },
+      detection: {
+        urlPatterns: ["/apistats", "/api/user-stats"],
+        healthMatch: { service: "*" }
+      },
+      responseMapping: {
+        billingMode: "subscription",
+        planName: "$.data.name",
+        "daily.used": "$.data.limits.currentDailyCost",
+        "daily.limit": "$.data.limits.dailyCostLimit",
+        "weekly.used": "$.data.limits.weeklyOpusCost",
+        "weekly.limit": "$.data.limits.weeklyOpusCostLimit",
+        "monthly.used": "$.data.limits.currentTotalCost",
+        "monthly.limit": "$.data.limits.totalCostLimit",
+        "tokenStats.total.requests": "$.data.usage.total.requests",
+        "tokenStats.total.inputTokens": "$.data.usage.total.inputTokens",
+        "tokenStats.total.outputTokens": "$.data.usage.total.outputTokens",
+        "tokenStats.total.cacheCreationTokens": "$.data.usage.total.cacheCreateTokens",
+        "tokenStats.total.cacheReadTokens": "$.data.usage.total.cacheReadTokens",
+        "tokenStats.total.totalTokens": "$.data.usage.total.tokens",
+        "tokenStats.total.cost": "$.data.usage.total.cost",
+        "rateLimit.windowSeconds": "$.data.limits.rateLimitWindow",
+        "rateLimit.requestsUsed": "$.data.limits.currentWindowRequests",
+        "rateLimit.requestsLimit": "$.data.limits.rateLimitRequests",
+        "rateLimit.costUsed": "$.data.limits.currentWindowCost",
+        "rateLimit.costLimit": "$.data.limits.rateLimitCost",
+        "rateLimit.remainingSeconds": "$.data.limits.windowRemainingSeconds"
+      }
+    }
+  };
 }
-function readProviderDetectionCache(baseUrl) {
-  const path = getProviderDetectionCachePath(baseUrl);
-  if (!existsSync5(path)) {
+
+// 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";
+function getLockFilePath(customDir) {
+  if (customDir) {
+    return join5(customDir, ".endpoint-config.lock");
+  }
+  return join5(homedir4(), ".claude", "cc-api-statusline", ".endpoint-config.lock");
+}
+function readEndpointLock(customDir) {
+  const lockPath = getLockFilePath(customDir);
+  if (!existsSync6(lockPath)) {
     return null;
   }
   try {
-    const content = readFileSync3(path, "utf-8");
+    const content = readFileSync4(lockPath, "utf-8");
     const data = JSON.parse(content);
-    if (!isProviderDetectionCacheEntry(data)) {
-      console.warn(`Invalid provider detection cache structure at ${path}`);
-      return null;
-    }
-    const detectedAt = new Date(data.detectedAt).getTime();
-    const now = Date.now();
-    const age = now - detectedAt;
-    const ttlMs = data.ttlSeconds * 1000;
-    if (age >= ttlMs) {
-      try {
-        unlinkSync2(path);
-      } catch {}
-      return null;
+    if (typeof data === "object" && data !== null && "hash" in data && "lockedAt" in data && typeof data.hash === "string" && typeof data.lockedAt === "string") {
+      return {
+        hash: data.hash,
+        lockedAt: data.lockedAt
+      };
     }
-    return data;
-  } catch (error) {
-    console.warn(`Failed to read provider detection cache from ${path}: ${error}`);
+    return null;
+  } catch {
     return null;
   }
 }
-function writeProviderDetectionCache(baseUrl, entry) {
-  const path = getProviderDetectionCachePath(baseUrl);
-  try {
-    ensureCacheDir();
-    const content = JSON.stringify(entry, null, 2);
-    atomicWriteFile(path, content);
-  } catch (error) {
-    console.warn(`Failed to write provider detection cache to ${path}: ${error}`);
-  }
+function writeEndpointLock(hash, customDir) {
+  const lockPath = getLockFilePath(customDir);
+  const entry = {
+    hash,
+    lockedAt: new Date().toISOString()
+  };
+  atomicWriteFile(lockPath, JSON.stringify(entry, null, 2), {
+    ensureParentDir: true,
+    appendNewline: true
+  });
 }
 
-// src/services/config.ts
-import { readFileSync as readFileSync4, existsSync as existsSync6 } 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) {
-  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;
+// src/services/config-defaults.ts
+function getDefaultStyleConfig() {
+  return DEFAULT_CONFIG;
+}
+function getDefaultSub2apiConfig() {
+  const configs = getBuiltInEndpointConfigs();
+  const config = configs["sub2api"];
+  if (!config)
+    throw new Error("Built-in sub2api config not found");
+  return config;
+}
+function getDefaultCrsConfig() {
+  const configs = getBuiltInEndpointConfigs();
+  const config = configs["claude-relay-service"];
+  if (!config)
+    throw new Error("Built-in claude-relay-service config not found");
+  return config;
+}
+function writeDefaultConfigs(customDir) {
+  const configDir = customDir || join6(homedir5(), ".claude", "cc-api-statusline");
+  const configPath = join6(configDir, "config.json");
+  const apiConfigDir = getEndpointConfigDir(customDir);
+  ensureDir(configDir);
+  ensureDir(apiConfigDir);
+  if (!existsSync7(configPath)) {
+    const styleConfig = getDefaultStyleConfig();
+    atomicWriteFile(configPath, JSON.stringify(styleConfig, null, 2), {
+      appendNewline: true
+    });
   }
-  if (pollIntervalSeconds !== undefined && pollIntervalSeconds < 5) {
-    console.warn("Warning: pollIntervalSeconds < 5, clamping to 5");
-    pollIntervalSeconds = 5;
+  const sub2apiPath = join6(apiConfigDir, "sub2api.json");
+  if (!existsSync7(sub2apiPath)) {
+    const sub2apiConfig = getDefaultSub2apiConfig();
+    atomicWriteFile(sub2apiPath, JSON.stringify(sub2apiConfig, null, 2), {
+      appendNewline: true
+    });
   }
-  if (pipedRequestTimeoutMs !== undefined && pipedRequestTimeoutMs < 100) {
-    console.warn("Warning: pipedRequestTimeoutMs < 100, clamping to 100");
-    pipedRequestTimeoutMs = 100;
+  const crsPath = join6(apiConfigDir, "crs.json");
+  if (!existsSync7(crsPath)) {
+    const crsConfig = getDefaultCrsConfig();
+    atomicWriteFile(crsPath, JSON.stringify(crsConfig, null, 2), {
+      appendNewline: true
+    });
   }
-  return {
-    ...config,
-    display: {
-      ...config.display,
-      maxWidth
-    },
-    pollIntervalSeconds,
-    pipedRequestTimeoutMs
-  };
+  const currentHash = computeEndpointConfigHash(customDir);
+  writeEndpointLock(currentHash, customDir);
 }
-function loadConfig(configPath) {
-  const path = getConfigPath(configPath);
-  if (!existsSync6(path)) {
-    return DEFAULT_CONFIG;
-  }
-  try {
-    const content = readFileSync4(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;
-  }
+function needsConfigInit(customDir) {
+  const configDir = customDir || join6(homedir5(), ".claude", "cc-api-statusline");
+  const configPath = join6(configDir, "config.json");
+  const apiConfigDir = getEndpointConfigDir(customDir);
+  return !existsSync7(configPath) || !existsSync7(apiConfigDir);
 }
 
 // src/providers/http.ts
@@ -816,76 +1087,419 @@ async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
   }
 }
 
-// src/services/user-agent.ts
-import { execSync as execSync2 } from "child_process";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+// src/providers/health-probe.ts
+function extractOrigin(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    return url.origin;
+  } catch {
+    return baseUrl;
+  }
+}
+async function probeHealth(baseUrl, timeoutMs = 1500) {
+  const origin = extractOrigin(baseUrl);
+  const healthUrl = `${origin}/health`;
+  logger.debug("Probing health endpoint", { healthUrl, timeoutMs });
+  try {
+    const responseText = await secureFetch(healthUrl, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      }
+    }, timeoutMs);
+    const data = JSON.parse(responseText);
+    logger.debug("Health probe response", { data });
+    if (typeof data["service"] === "string") {
+      logger.debug("Detected provider from service field", { provider: data["service"] });
+      return data["service"];
+    }
+    if (data["status"] === "ok") {
+      logger.debug("Detected sub2api from status: ok pattern");
+      return "sub2api";
+    }
+    logger.debug("Health probe returned unrecognized pattern", { data });
+    return null;
+  } catch (error) {
+    logger.debug("Health probe failed", { error: String(error) });
+    return null;
+  }
+}
 
-// src/services/logger.ts
-import { appendFileSync } from "fs";
-import { join as join4, dirname as dirname2 } 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();
+// 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";
+function getCacheDir() {
+  const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
+  if (override) {
+    return override;
+  }
+  return join7(homedir6(), ".claude", "cc-api-statusline");
+}
+function ensureCacheDir() {
+  const dir = getCacheDir();
+  ensureDir(dir);
+}
+function getCachePath(baseUrl) {
+  const hash = shortHash(baseUrl, 12);
+  return join7(getCacheDir(), `cache-${hash}.json`);
+}
+function readCache(baseUrl) {
+  const path = getCachePath(baseUrl);
+  if (!existsSync8(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync5(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;
   }
-  ensureLogDir() {
-    try {
-      const dir = dirname2(this.logPath);
-      ensureDir(dir);
-    } catch {
-      this.enabled = false;
+}
+function writeCache(baseUrl, entry) {
+  const path = getCachePath(baseUrl);
+  try {
+    ensureCacheDir();
+    const content = JSON.stringify(entry, null, 2);
+    atomicWriteFile(path, content);
+  } catch (error) {
+    console.warn(`Failed to write cache to ${path}: ${error}`);
+  }
+}
+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 (!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) {
+    return Math.max(5, envOverride);
+  }
+  const fromConfig = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
+  return Math.max(5, fromConfig);
+}
+function getProviderDetectionCachePath(baseUrl) {
+  const hash = shortHash(baseUrl, 12);
+  return join7(getCacheDir(), `provider-detect-${hash}.json`);
+}
+function readProviderDetectionCache(baseUrl) {
+  const path = getProviderDetectionCachePath(baseUrl);
+  if (!existsSync8(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync5(path, "utf-8");
+    const data = JSON.parse(content);
+    if (!isProviderDetectionCacheEntry(data)) {
+      console.warn(`Invalid provider detection cache structure at ${path}`);
+      return null;
+    }
+    const detectedAt = new Date(data.detectedAt).getTime();
+    const now = Date.now();
+    const age = now - detectedAt;
+    const ttlMs = data.ttlSeconds * 1000;
+    if (age >= ttlMs) {
+      try {
+        unlinkSync4(path);
+      } catch {}
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.warn(`Failed to read provider detection cache from ${path}: ${error}`);
+    return null;
+  }
+}
+function writeProviderDetectionCache(baseUrl, entry) {
+  const path = getProviderDetectionCachePath(baseUrl);
+  try {
+    ensureCacheDir();
+    const content = JSON.stringify(entry, null, 2);
+    atomicWriteFile(path, content);
+  } catch (error) {
+    console.warn(`Failed to write provider detection cache to ${path}: ${error}`);
+  }
+}
+
+// src/providers/autodetect.ts
+var detectionCache = new Map;
+function detectProviderFromUrlPattern(baseUrl, endpointConfigs = {}) {
+  const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
+  for (const [providerId, config] of Object.entries(endpointConfigs)) {
+    const urlPatterns = config.detection?.urlPatterns;
+    if (urlPatterns && urlPatterns.length > 0) {
+      for (const pattern of urlPatterns) {
+        const normalizedPattern = pattern.toLowerCase();
+        if (normalizedUrl.includes(normalizedPattern)) {
+          return providerId;
+        }
+      }
     }
   }
-  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)}`;
+  if (normalizedUrl.includes("/apistats") || normalizedUrl.includes("/api/user-stats")) {
+    return "claude-relay-service";
   }
-  format(level, message, data) {
-    const timestamp = this.formatLocalTimestamp();
-    const dataStr = data ? ` ${JSON.stringify(data)}` : "";
-    return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}
-`;
+  return "sub2api";
+}
+async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {}, probeTimeoutMs = 1500) {
+  if (providerOverride) {
+    logger.debug("Provider override detected", { provider: providerOverride });
+    return providerOverride;
+  }
+  const cached = detectionCache.get(baseUrl);
+  if (cached) {
+    logger.debug("Provider detection cache hit (memory)", { provider: cached.provider });
+    return cached.provider;
+  }
+  const diskCached = readProviderDetectionCache(baseUrl);
+  if (diskCached) {
+    logger.debug("Provider detection cache hit (disk)", {
+      provider: diskCached.provider,
+      detectedVia: diskCached.detectedVia
+    });
+    detectionCache.set(baseUrl, {
+      provider: diskCached.provider,
+      detectedAt: diskCached.detectedAt
+    });
+    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;
+        }
+      }
+    }
+  }
+  logger.debug("Attempting health probe", { baseUrl, timeoutMs: probeTimeoutMs });
+  const probedProvider = await probeHealth(baseUrl, probeTimeoutMs);
+  if (probedProvider) {
+    logger.debug("Provider detected via health probe", { provider: probedProvider });
+    cacheProviderDetection(baseUrl, probedProvider, "health-probe");
+    return probedProvider;
+  }
+  const patternProvider = detectProviderFromUrlPattern(baseUrl, {});
+  logger.debug("Provider detected via built-in URL pattern", { provider: patternProvider });
+  cacheProviderDetection(baseUrl, patternProvider, "url-pattern");
+  return patternProvider;
+}
+function cacheProviderDetection(baseUrl, provider, detectedVia) {
+  const now = new Date().toISOString();
+  detectionCache.set(baseUrl, {
+    provider,
+    detectedAt: now
+  });
+  writeProviderDetectionCache(baseUrl, {
+    baseUrl,
+    provider,
+    detectedVia,
+    detectedAt: now,
+    ttlSeconds: PROVIDER_DETECTION_TTL_SECONDS
+  });
+}
+function clearDetectionCache() {
+  detectionCache.clear();
+}
+
+// src/cli/commands.ts
+import { existsSync as existsSync9, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
+import { join as join8 } from "path";
+function handleInstall(args) {
+  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");
+  console.log("Creating default configuration files...");
+  writeDefaultConfigs();
+  console.log("✓ Config files created:");
+  console.log("  - ~/.claude/cc-api-statusline/config.json");
+  console.log("  - ~/.claude/cc-api-statusline/api-config/sub2api.json");
+  console.log("  - ~/.claude/cc-api-statusline/api-config/crs.json");
+  console.log("  - ~/.claude/cc-api-statusline/.endpoint-config.lock");
+  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);
+}
+function handleUninstall() {
+  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);
+}
+function handleApplyConfig() {
+  console.log("Applying endpoint configuration changes...");
+  const currentHash = computeEndpointConfigHash();
+  console.log(`Current endpoint config hash: ${currentHash}`);
+  clearDetectionCache();
+  console.log("✓ Provider detection cache cleared");
+  const cacheDir = getCacheDir();
+  let failCount = 0;
+  if (existsSync9(cacheDir)) {
+    const files = readdirSync3(cacheDir).filter((f) => f.startsWith("cache-") && f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const filePath = join8(cacheDir, file);
+        unlinkSync5(filePath);
+      } catch {
+        failCount++;
+      }
+    }
+    if (failCount > 0) {
+      console.log(`⚠ Cleared ${files.length - failCount}/${files.length} cache files (${failCount} failed)`);
+    } else {
+      console.log(`✓ Cleared ${files.length} data cache file(s)`);
+    }
+  }
+  writeEndpointLock(currentHash);
+  console.log("✓ Lock file updated");
+  console.log("");
+  console.log("✓ Endpoint config changes applied successfully!");
+  console.log("  Changes will take effect on next statusline refresh.");
+  console.log("");
+  console.log("Config files:");
+  const apiConfigDir = getEndpointConfigDir();
+  if (existsSync9(apiConfigDir)) {
+    const configFiles = readdirSync3(apiConfigDir).filter((f) => f.endsWith(".json"));
+    for (const file of configFiles) {
+      console.log(`  - ${apiConfigDir}/${file}`);
+    }
+  }
+  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;
   }
-  write(level, message, data) {
-    if (!this.enabled) {
-      return;
+  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;
     }
-    try {
-      const entry = this.format(level, message, data);
-      appendFileSync(this.logPath, entry, { encoding: "utf-8" });
-    } catch {}
   }
-  debug(message, data) {
-    this.write("debug", message, data);
+  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;
   }
-  info(message, data) {
-    this.write("info", message, data);
+  if (maxWidth > 100) {
+    console.warn("Warning: display.maxWidth > 100, clamping to 100");
+    maxWidth = 100;
   }
-  warn(message, data) {
-    this.write("warn", message, data);
+  if (pollIntervalSeconds !== undefined && pollIntervalSeconds < 5) {
+    console.warn("Warning: pollIntervalSeconds < 5, clamping to 5");
+    pollIntervalSeconds = 5;
   }
-  error(message, data) {
-    this.write("error", message, data);
+  if (pipedRequestTimeoutMs !== undefined && pipedRequestTimeoutMs < 100) {
+    console.warn("Warning: pipedRequestTimeoutMs < 100, clamping to 100");
+    pipedRequestTimeoutMs = 100;
   }
-  isEnabled() {
-    return this.enabled;
+  return {
+    ...config,
+    display: {
+      ...config.display,
+      maxWidth
+    },
+    pollIntervalSeconds,
+    pipedRequestTimeoutMs
+  };
+}
+function loadConfig(configPath) {
+  const path = getConfigPath(configPath);
+  if (!existsSync10(path)) {
+    return DEFAULT_CONFIG;
   }
-  getLogPath() {
-    return this.logPath;
+  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;
   }
 }
-var logger = new Logger;
 
 // src/services/user-agent.ts
+import { execSync as execSync2 } from "child_process";
+import { join as join10 } from "path";
+import { homedir as homedir8 } from "os";
 var FALLBACK_UA = "claude-cli/2.1.56 (external, cli)";
 function resolveUserAgent(config) {
   if (!config) {
@@ -912,7 +1526,7 @@ function detectClaudeVersion() {
     if (!process.env["CLAUDECODE"]) {
       return null;
     }
-    const claudePath = join5(homedir5(), ".claude", "bin", "claude");
+    const claudePath = join10(homedir8(), ".claude", "bin", "claude");
     const result = execSync2(`"${claudePath}" --version`, {
       encoding: "utf-8",
       timeout: 1000,
@@ -942,15 +1556,6 @@ function createQuotaWindow(used, limit, resetsAt) {
   };
 }
 
-// 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;
-
 // src/providers/sub2api.ts
 function mapPeriodTokens(data) {
   if (!data)
@@ -1027,44 +1632,6 @@ async function fetchSub2api(baseUrl, token, config, timeoutMs = DEFAULT_FETCH_TI
   };
 }
 
-// src/providers/health-probe.ts
-function extractOrigin(baseUrl) {
-  try {
-    const url = new URL(baseUrl);
-    return url.origin;
-  } catch {
-    return baseUrl;
-  }
-}
-async function probeHealth(baseUrl, timeoutMs = 1500) {
-  const origin = extractOrigin(baseUrl);
-  const healthUrl = `${origin}/health`;
-  logger.debug("Probing health endpoint", { healthUrl, timeoutMs });
-  try {
-    const responseText = await secureFetch(healthUrl, {
-      method: "GET",
-      headers: {
-        Accept: "application/json"
-      }
-    }, timeoutMs);
-    const data = JSON.parse(responseText);
-    logger.debug("Health probe response", { data });
-    if (typeof data["service"] === "string") {
-      logger.debug("Detected provider from service field", { provider: data["service"] });
-      return data["service"];
-    }
-    if (data["status"] === "ok") {
-      logger.debug("Detected sub2api from status: ok pattern");
-      return "sub2api";
-    }
-    logger.debug("Health probe returned unrecognized pattern", { data });
-    return null;
-  } catch (error) {
-    logger.debug("Health probe failed", { error: String(error) });
-    return null;
-  }
-}
-
 // src/services/time.ts
 function computeNextMidnightLocal() {
   const now = new Date;
@@ -1158,7 +1725,7 @@ async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = DEFAU
   };
 }
 
-// src/providers/custom-mapping.ts
+// src/providers/response-mapping.ts
 function resolveJsonPath(data, path) {
   if (!path.startsWith("$.")) {
     return path;
@@ -1236,11 +1803,11 @@ function extractTokenStatsPeriod(data, mapping, prefix) {
     cost: extractNumber(data, mapping[`${prefix}.cost`]) ?? 0
   };
 }
-function mapResponseToUsage(responseData, mapping, providerConfig) {
+function mapResponseToUsage(responseData, mapping, endpointConfig) {
   const billingModeStr = extractString(responseData, mapping.billingMode, "subscription");
   const billingMode = billingModeStr === "balance" ? "balance" : "subscription";
-  const planName = extractString(responseData, mapping.planName, providerConfig.displayName ?? providerConfig.id);
-  const base = createEmptyNormalizedUsage(providerConfig.id, billingMode, planName);
+  const planName = extractString(responseData, mapping.planName, endpointConfig.displayName ?? endpointConfig.provider);
+  const base = createEmptyNormalizedUsage(endpointConfig.provider, billingMode, planName);
   const balance = mapping["balance.remaining"] ? (() => {
     const remaining = extractNumber(responseData, mapping["balance.remaining"]);
     if (remaining === null)
@@ -1303,159 +1870,75 @@ function mapResponseToUsage(responseData, mapping, providerConfig) {
   };
 }
 
-// src/providers/custom.ts
-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";
+// src/providers/endpoint-fetch.ts
+function validateEndpointConfig2(config) {
+  if (!config.provider)
+    return "Endpoint config missing required field: provider";
+  if (!config.endpoint?.path)
+    return "Endpoint config missing required field: endpoint.path";
+  if (!config.endpoint?.method)
+    return "Endpoint config missing required field: endpoint.method";
+  if (!config.auth)
+    return "Endpoint config missing required field: auth";
+  if (!config.responseMapping)
+    return "Endpoint config missing required field: responseMapping";
+  if (!config.endpoint.path.startsWith("/")) {
+    return "Endpoint path must start with /";
+  }
+  if (config.auth.type === "custom-header" && !config.auth.header) {
+    return 'Auth type="custom-header" requires auth.header';
+  }
+  if (config.auth.type === "body-key" && !config.auth.bodyField) {
+    return 'Auth type="body-key" requires auth.bodyField';
   }
   return null;
 }
-async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const validationError = validateCustomProvider(providerConfig);
+async function fetchEndpoint(baseUrl, token, appConfig, endpointConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+  const validationError = validateEndpointConfig2(endpointConfig);
   if (validationError) {
-    throw new Error(`Invalid custom provider providerConfig: ${validationError}`);
+    throw new Error(`Invalid endpoint config: ${validationError}`);
   }
-  const url = `${baseUrl}${providerConfig.endpoint}`;
+  const url = `${baseUrl}${endpointConfig.endpoint.path}`;
   const headers = {
     Accept: "application/json"
   };
-  if (providerConfig.contentType) {
-    headers["Content-Type"] = providerConfig.contentType;
+  if (endpointConfig.endpoint.contentType) {
+    headers["Content-Type"] = endpointConfig.endpoint.contentType;
   }
-  if (providerConfig.auth.type === "header" && providerConfig.auth.header) {
-    const prefix = providerConfig.auth.prefix ?? "";
-    headers[providerConfig.auth.header] = `${prefix}${token}`;
+  if (endpointConfig.auth.type === "bearer-header") {
+    const prefix = endpointConfig.auth.prefix ?? "Bearer ";
+    headers["Authorization"] = `${prefix}${token}`;
+  } else if (endpointConfig.auth.type === "custom-header" && endpointConfig.auth.header) {
+    const prefix = endpointConfig.auth.prefix ?? "";
+    headers[endpointConfig.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;
+  if (endpointConfig.endpoint.method === "POST") {
+    if (endpointConfig.auth.type === "body-key" && endpointConfig.auth.bodyField) {
+      const bodyObj = { ...endpointConfig.requestBody ?? {} };
+      bodyObj[endpointConfig.auth.bodyField] = token;
       body = JSON.stringify(bodyObj);
-    } else if (providerConfig.requestBody) {
-      body = JSON.stringify(providerConfig.requestBody);
+    } else if (endpointConfig.requestBody) {
+      body = JSON.stringify(endpointConfig.requestBody);
     }
   }
-  const providerUA = providerConfig.spoofClaudeCodeUA;
+  const endpointUA = endpointConfig.spoofClaudeCodeUA;
   const globalUA = appConfig.spoofClaudeCodeUA;
-  const effectiveUA = providerUA !== undefined ? providerUA : globalUA;
+  const effectiveUA = endpointUA !== undefined ? endpointUA : globalUA;
   const resolvedUA = resolveUserAgent(effectiveUA);
   if (resolvedUA) {
-    logger.debug(`Using User-Agent for ${providerConfig.id}: ${resolvedUA}`);
+    logger.debug(`Using User-Agent for ${endpointConfig.provider}: ${resolvedUA}`);
   }
   const responseText = await secureFetch(url, {
-    method: providerConfig.method,
+    method: endpointConfig.endpoint.method,
     headers,
     body
   }, timeoutMs, resolvedUA);
   const responseData = JSON.parse(responseText);
-  const result = mapResponseToUsage(responseData, providerConfig.responseMapping, providerConfig);
+  const result = mapResponseToUsage(responseData, endpointConfig.responseMapping, endpointConfig);
   return result;
 }
 
-// src/providers/autodetect.ts
-var detectionCache = new Map;
-function detectProviderFromUrlPattern(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("/api/user-stats")) {
-    return "claude-relay-service";
-  }
-  return "sub2api";
-}
-async function resolveProvider(baseUrl, providerOverride, customProviders = {}, probeTimeoutMs = 1500) {
-  if (providerOverride) {
-    logger.debug("Provider override detected", { provider: providerOverride });
-    return providerOverride;
-  }
-  const cached = detectionCache.get(baseUrl);
-  if (cached) {
-    logger.debug("Provider detection cache hit (memory)", { provider: cached.provider });
-    return cached.provider;
-  }
-  const diskCached = readProviderDetectionCache(baseUrl);
-  if (diskCached) {
-    logger.debug("Provider detection cache hit (disk)", {
-      provider: diskCached.provider,
-      detectedVia: diskCached.detectedVia
-    });
-    detectionCache.set(baseUrl, {
-      provider: diskCached.provider,
-      detectedAt: diskCached.detectedAt
-    });
-    return diskCached.provider;
-  }
-  for (const [providerId, config] of Object.entries(customProviders)) {
-    if (config.urlPatterns && config.urlPatterns.length > 0) {
-      const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
-      for (const pattern of config.urlPatterns) {
-        const normalizedPattern = pattern.toLowerCase();
-        if (normalizedUrl.includes(normalizedPattern)) {
-          logger.debug("Provider detected via custom URL pattern", { provider: providerId, pattern });
-          cacheProviderDetection(baseUrl, providerId, "url-pattern");
-          return providerId;
-        }
-      }
-    }
-  }
-  logger.debug("Attempting health probe", { baseUrl, timeoutMs: probeTimeoutMs });
-  const probedProvider = await probeHealth(baseUrl, probeTimeoutMs);
-  if (probedProvider) {
-    logger.debug("Provider detected via health probe", { provider: probedProvider });
-    cacheProviderDetection(baseUrl, probedProvider, "health-probe");
-    return probedProvider;
-  }
-  const patternProvider = detectProviderFromUrlPattern(baseUrl, {});
-  logger.debug("Provider detected via built-in URL pattern", { provider: patternProvider });
-  cacheProviderDetection(baseUrl, patternProvider, "url-pattern");
-  return patternProvider;
-}
-function cacheProviderDetection(baseUrl, provider, detectedVia) {
-  const now = new Date().toISOString();
-  detectionCache.set(baseUrl, {
-    provider,
-    detectedAt: now
-  });
-  writeProviderDetectionCache(baseUrl, {
-    baseUrl,
-    provider,
-    detectedVia,
-    detectedAt: now,
-    ttlSeconds: PROVIDER_DETECTION_TTL_SECONDS
-  });
-}
-
 // src/providers/index.ts
 var BUILT_IN_ADAPTERS = {
   sub2api: {
@@ -1465,14 +1948,14 @@ var BUILT_IN_ADAPTERS = {
     fetch: fetchClaudeRelayService
   }
 };
-function getProvider(providerId, customProviders = {}) {
+function getProvider(providerId, endpointConfigs = {}) {
   if (BUILT_IN_ADAPTERS[providerId]) {
     return BUILT_IN_ADAPTERS[providerId];
   }
-  const customConfig = customProviders[providerId];
-  if (customConfig) {
+  const endpointConfig = endpointConfigs[providerId];
+  if (endpointConfig) {
     return {
-      fetch: (baseUrl, token, config, timeoutMs) => fetchCustom(baseUrl, token, config, customConfig, timeoutMs)
+      fetch: (baseUrl, token, config, timeoutMs) => fetchEndpoint(baseUrl, token, config, endpointConfig, timeoutMs)
     };
   }
   return null;
@@ -1501,10 +1984,30 @@ var ANSI_COLORS = {
 };
 var THEME_COLORS = {
   cool: "#56B6C2",
-  comfortable: "#6BAF8D",
+  comfortable: "#5EBE8A",
   warm: "#C9A84C",
-  hot: "#CB7E55",
-  critical: "#C96B6B"
+  hot: "#D68B45",
+  critical: "#D45A5A",
+  "pastel-cool": "#BAD7F2",
+  "pastel-comfortable": "#BAF2D8",
+  "pastel-medium": "#BAF2BB",
+  "pastel-warm": "#F2E2BA",
+  "pastel-hot": "#F2BAC9",
+  "bright-cool": "#90F1EF",
+  "bright-comfortable": "#7BF1A8",
+  "bright-medium": "#C1FBA4",
+  "bright-warm": "#FFEF9F",
+  "bright-hot": "#FFD6E0",
+  "ocean-cool": "#0081A7",
+  "ocean-comfortable": "#00AFB9",
+  "ocean-medium": "#FDFCDC",
+  "ocean-warm": "#FED9B7",
+  "ocean-hot": "#F07167",
+  "neutral-cool": "#D8E2DC",
+  "neutral-comfortable": "#FFE5D9",
+  "neutral-warm": "#FFCAD4",
+  "neutral-hot": "#F4ACB7",
+  "neutral-critical": "#9D8189"
 };
 var ANSI_RESET = "\x1B[0m";
 var ANSI_DIM = "\x1B[2m";
@@ -1614,9 +2117,6 @@ function resolveColor(colorName, usagePercent, config) {
   }
   return resolveColorAlias(alias, usagePercent);
 }
-function isTieredEntry(alias) {
-  return "tiers" in alias;
-}
 function resolveTieredColor(entry, usagePercent) {
   if (entry.tiers.length === 0)
     return null;
@@ -1633,19 +2133,7 @@ function resolveTieredColor(entry, usagePercent) {
 function resolveColorAlias(alias, usagePercent) {
   if (!alias)
     return null;
-  if (isTieredEntry(alias)) {
-    return resolveTieredColor(alias, usagePercent);
-  }
-  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;
-  }
+  return resolveTieredColor(alias, usagePercent);
 }
 
 // src/renderer/transition.ts
@@ -1696,6 +2184,8 @@ function renderStandaloneError(errorState, provider, message) {
       return `${warningIcon} Set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN`;
     case "timeout":
       return `${warningIcon} Fetching...`;
+    case "endpoint-config-changed":
+      return `${warningIcon} Endpoint config changed — run: cc-api-statusline --apply-config`;
     case "network-error":
     case "server-error":
     case "parse-error":
@@ -2481,10 +2971,10 @@ function isComponentId(key) {
 
 // src/core/execute-cycle.ts
 async function executeCycle(ctx) {
-  const { env, config, configHash, cachedEntry, providerId, provider, timeoutBudgetMs, startTime, fetchTimeoutMs } = ctx;
+  const { env, config, configHash, endpointConfigHash, endpointLock, cachedEntry, providerId, provider, timeoutBudgetMs, startTime, fetchTimeoutMs } = ctx;
   if (cachedEntry) {
     if (isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
-      if (cachedEntry.renderedLine && isCacheRenderedLineUsable(cachedEntry, configHash)) {
+      if (cachedEntry.renderedLine && isCacheRenderedLineUsable(cachedEntry, configHash) && cachedEntry.endpointConfigHash === endpointConfigHash) {
         logger.debug("Path A: Fast path (cached renderedLine)", {
           cacheAge: `${Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 1000)}s`
         });
@@ -2496,13 +2986,34 @@ async function executeCycle(ctx) {
       }
     }
   }
+  if (endpointLock && endpointLock.hash !== endpointConfigHash) {
+    logger.debug("Path B2: Endpoint config changed (locked out)", {
+      lockedHash: endpointLock.hash,
+      currentHash: endpointConfigHash
+    });
+    if (cachedEntry && isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
+      const statusline = renderStatusline(cachedEntry.data, config);
+      return {
+        output: statusline,
+        exitCode: 0,
+        cacheUpdate: null
+      };
+    }
+    const errorOutput = renderError("endpoint-config-changed", "without-cache");
+    return {
+      output: errorOutput,
+      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
+      configHash,
+      endpointConfigHash
     };
     return {
       output: statusline,
@@ -2548,6 +3059,7 @@ async function executeCycle(ctx) {
       data,
       renderedLine: statusline,
       configHash,
+      endpointConfigHash,
       errorState: null
     };
     return {
@@ -2582,23 +3094,23 @@ async function executeCycle(ctx) {
   }
 }
 // src/services/cache-gc.ts
-import { readdirSync, statSync, unlinkSync as unlinkSync3, existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import { readdirSync as readdirSync4, statSync as statSync2, unlinkSync as unlinkSync6, existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
 function runCacheGC(cacheDir) {
   try {
-    if (!existsSync7(cacheDir)) {
+    if (!existsSync11(cacheDir)) {
       logger.debug("GC: Cache directory does not exist, skipping", { cacheDir });
       return;
     }
     logger.debug("GC: Starting garbage collection", { cacheDir });
-    const files = readdirSync(cacheDir);
+    const files = readdirSync4(cacheDir);
     const cacheFiles = [];
     const providerDetectFiles = [];
     const tmpFiles = [];
     for (const file of files) {
       try {
-        const filePath = join6(cacheDir, file);
-        const stats = statSync(filePath);
+        const filePath = join11(cacheDir, file);
+        const stats = statSync2(filePath);
         const mtime = stats.mtimeMs;
         if (file.startsWith("cache-") && file.endsWith(".json")) {
           cacheFiles.push({ name: file, mtime });
@@ -2617,7 +3129,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_MAX_AGE_MS) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join11(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted old cache file", { file: file.name, ageDays: Math.floor(age / (24 * 60 * 60 * 1000)) });
         } catch (error) {
@@ -2629,7 +3141,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_MAX_AGE_MS) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join11(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) {
@@ -2641,7 +3153,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_ORPHAN_TMP_AGE_MS) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join11(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted orphaned tmp file", { file: file.name, ageMinutes: Math.floor(age / (60 * 1000)) });
         } catch (error) {
@@ -2658,7 +3170,7 @@ function runCacheGC(cacheDir) {
       const toDelete = remainingCacheFiles.slice(0, remainingCacheFiles.length - GC_MAX_CACHE_FILES);
       for (const file of toDelete) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join11(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted cache file (count limit)", { file: file.name });
         } catch (error) {
@@ -2673,60 +3185,123 @@ function runCacheGC(cacheDir) {
 }
 
 // src/cli/piped-mode.ts
-function buildExecutionContext(args, isPiped, startTime) {
-  return (async () => {
-    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
+class StatuslineError extends Error {
+  errorType;
+  constructor(errorType) {
+    super(errorType);
+    this.errorType = errorType;
+  }
+}
+function readAndValidateEnv() {
+  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) {
+    throw new StatuslineError("missing-env");
+  }
+  const { baseUrl } = env;
+  if (!baseUrl) {
+    process.exit(1);
+  }
+  return { env, baseUrl };
+}
+function ensureDefaultConfigs() {
+  if (needsConfigInit()) {
+    logger.debug("First run detected - initializing default configs");
+    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();
+  logger.debug("Endpoint configs loaded", {
+    configCount: Object.keys(endpointConfigs).length,
+    endpointConfigHash
+  });
+  return { endpointConfigs, endpointConfigHash };
+}
+function resolveEndpointLock(hash) {
+  const existing = readEndpointLock();
+  if (existing) {
+    logger.debug("Endpoint lock file loaded", {
+      lockedHash: existing.hash,
+      currentHash: hash,
+      locked: existing.hash === hash
     });
-    const envError = validateRequiredEnv(env);
-    if (envError) {
-      const errorOutput = renderError("missing-env", "without-cache");
-      process.stdout.write(errorOutput);
-      process.exit(0);
-    }
-    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 probeTimeout = isPiped ? Math.min(1500, Math.max(200, Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000) - 200)) : 3000;
-    const providerId = await resolveProvider(baseUrl, env.providerOverride, config.customProviders ?? {}, probeTimeout);
-    const provider = getProvider(providerId, config.customProviders ?? {});
-    logger.debug("Provider resolved", { providerId, probeTimeout });
-    if (!provider) {
-      logger.error("Provider not found", { providerId });
-      const errorOutput = renderError("provider-unknown", "without-cache");
-      process.stdout.write(errorOutput);
-      process.exit(0);
+    return existing;
+  }
+  logger.debug("Endpoint lock file missing - creating with current hash");
+  writeEndpointLock(hash);
+  return { hash, lockedAt: new Date().toISOString() };
+}
+async function resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, timeoutMs) {
+  const probeTimeout = isPiped ? Math.min(1500, Math.max(200, timeoutMs - 200)) : 3000;
+  const providerId = await resolveProvider(baseUrl, env.providerOverride, endpointConfigs, probeTimeout);
+  const provider = getProvider(providerId, endpointConfigs);
+  logger.debug("Provider resolved", { providerId, probeTimeout });
+  if (!provider) {
+    logger.error("Provider not found", { providerId });
+    throw new StatuslineError("provider-unknown");
+  }
+  return { providerId, provider };
+}
+function computeTimeoutBudgets(isPiped, config, timeoutMs) {
+  const timeoutBudgetMs = isPiped ? timeoutMs : 1e4;
+  const fetchTimeoutMs = isPiped ? Math.min(config.pipedRequestTimeoutMs ?? 800, timeoutBudgetMs - 100) : 1e4;
+  return { timeoutBudgetMs, fetchTimeoutMs };
+}
+async function buildExecutionContext(args, isPiped, startTime, rawTimeoutMs) {
+  const { env, baseUrl } = readAndValidateEnv();
+  ensureDefaultConfigs();
+  const { config, configHash } = loadConfigWithHash(args.configPath);
+  const { endpointConfigs, endpointConfigHash } = loadEndpointConfigsWithHash();
+  const endpointLock = resolveEndpointLock(endpointConfigHash);
+  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"
+  });
+  let providerId;
+  let provider;
+  if (cachedEntry && isCacheValid(cachedEntry, env)) {
+    const cachedProvider = getProvider(cachedEntry.provider, endpointConfigs);
+    if (cachedProvider) {
+      providerId = cachedEntry.provider;
+      provider = cachedProvider;
+      logger.debug("Cache-first: skipping provider probe", { providerId });
+    } else {
+      ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs));
     }
-    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
-    };
-    return { ctx, baseUrl };
-  })();
+  } else {
+    ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs));
+  }
+  const { timeoutBudgetMs, fetchTimeoutMs } = computeTimeoutBudgets(isPiped, config, rawTimeoutMs);
+  const ctx = {
+    env,
+    config,
+    configHash,
+    endpointConfigHash,
+    endpointLock,
+    cachedEntry,
+    providerId,
+    provider,
+    timeoutBudgetMs,
+    startTime,
+    fetchTimeoutMs
+  };
+  return { ctx, baseUrl };
 }
 function formatOutput(output, isPiped) {
   let normalizedOutput = output;
@@ -2748,12 +3323,45 @@ async function executePipedMode(args) {
   logger.debug("Start time", { startTime });
   const isPiped = !process.stdin.isTTY;
   logger.debug("Mode detection", { isPiped, once: args.once });
-  const { ctx, baseUrl } = await buildExecutionContext(args, isPiped, startTime);
+  const rawTimeoutMs = Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000);
+  if (isPiped) {
+    const watchdogMs = rawTimeoutMs - 100;
+    setTimeout(() => {
+      logger.error("Watchdog timeout - forcing clean exit", { watchdogMs });
+      const fallback = dimText("⟳ Refreshing...");
+      const formatted = formatOutput(fallback, isPiped);
+      process.stdout.write(formatted);
+      process.exit(0);
+    }, watchdogMs).unref();
+  }
+  let ctx;
+  let baseUrl;
+  try {
+    ({ ctx, baseUrl } = await buildExecutionContext(args, isPiped, startTime, rawTimeoutMs));
+  } catch (error) {
+    logger.error("Failed to build execution context", { error: String(error) });
+    const errorType = error instanceof StatuslineError ? error.errorType : "network-error";
+    const errorOutput = renderError(errorType, "without-cache");
+    const formattedOutput2 = formatOutput(errorOutput, isPiped);
+    process.stdout.write(formattedOutput2);
+    logger.debug("=== cc-api-statusline execution completed ===");
+    process.exit(0);
+  }
   logger.debug("Execution context prepared", {
     timeoutBudgetMs: ctx.timeoutBudgetMs,
     fetchTimeoutMs: ctx.fetchTimeoutMs
   });
-  const result = await executeCycle(ctx);
+  let result;
+  try {
+    result = await executeCycle(ctx);
+  } catch (error) {
+    logger.error("Execution cycle failed", { error: String(error) });
+    const errorOutput = renderError("network-error", "without-cache");
+    const formattedOutput2 = formatOutput(errorOutput, isPiped);
+    process.stdout.write(formattedOutput2);
+    logger.debug("=== cc-api-statusline execution completed ===");
+    process.exit(0);
+  }
   const executionTime = Date.now() - startTime;
   logger.debug("Execution completed", {
     exitCode: result.exitCode,
@@ -2776,6 +3384,7 @@ function discardStdin() {
   if (!process.stdin.isTTY) {
     process.stdin.resume();
     process.stdin.on("data", () => {});
+    process.stdin.on("error", () => {});
   }
 }
 async function main() {
@@ -2799,6 +3408,10 @@ async function main() {
     handleUninstall();
     return;
   }
+  if (args.applyConfig) {
+    handleApplyConfig();
+    return;
+  }
   if (process.stdin.isTTY && !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.");
@@ -2806,6 +3419,13 @@ async function main() {
   }
   await executePipedMode(args);
 }
+process.on("SIGTERM", () => {
+  process.exit(0);
+});
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught exception", { error: String(error) });
+  process.exit(0);
+});
 main().catch((error) => {
   logger.error("Unhandled error in main", { error: String(error) });
   console.error(`Fatal error: ${error}`);