cc-api-statusline 0.1.1 → 0.1.3

package/dist/cc-api-statusline.js

@@ -134,7 +134,7 @@ var DEFAULT_CONFIG = {
     barSize: "medium",
     barStyle: "classic",
     separator: " | ",
-    maxWidth: 80,
+    maxWidth: 100,
     clockFormat: "24h"
   },
   components: {
@@ -209,6 +209,13 @@ function isCacheEntry(value) {
   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");
 }
+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/cache.ts
 function getCacheDir() {
   const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
@@ -310,6 +317,58 @@ function getEffectivePollInterval(config, envOverride) {
   const fromConfig = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
   return Math.max(5, fromConfig);
 }
+function getProviderDetectionCachePath(baseUrl) {
+  const hash = shortHash(baseUrl, 12);
+  return join2(getCacheDir(), `provider-detect-${hash}.json`);
+}
+function readProviderDetectionCache(baseUrl) {
+  const path = getProviderDetectionCachePath(baseUrl);
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(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 {
+        unlinkSync(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);
+  const tmpPath = `${path}.tmp`;
+  try {
+    ensureCacheDir();
+    const content = JSON.stringify(entry, null, 2);
+    writeFileSync(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    try {
+      chmodSync(tmpPath, 384);
+    } catch {}
+    renameSync(tmpPath, path);
+  } catch (error) {
+    console.warn(`Failed to write provider detection cache to ${path}: ${error}`);
+    try {
+      if (existsSync2(tmpPath)) {
+        unlinkSync(tmpPath);
+      }
+    } catch {}
+  }
+}
 
 // src/services/config.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
@@ -557,8 +616,13 @@ class Logger {
       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 = new Date().toISOString();
+    const timestamp = this.formatLocalTimestamp();
     const dataStr = data ? ` ${JSON.stringify(data)}` : "";
     return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}
 `;
@@ -634,21 +698,21 @@ function detectClaudeVersion() {
 }
 
 // src/providers/sub2api.ts
-function computeNextMidnightUTC() {
+function computeNextMidnightLocal() {
   const now = new Date;
-  const tomorrow = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, 0, 0, 0, 0));
+  const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 0, 0);
   return tomorrow.toISOString();
 }
-function computeNextMondayUTC() {
+function computeNextMondayLocal() {
   const now = new Date;
-  const dayOfWeek = now.getUTCDay();
+  const dayOfWeek = now.getDay();
   const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
-  const nextMonday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0, 0));
+  const nextMonday = new Date(now.getFullYear(), now.getMonth(), now.getDate() + daysUntilMonday, 0, 0, 0, 0);
   return nextMonday.toISOString();
 }
-function computeFirstOfNextMonthUTC() {
+function computeFirstOfNextMonthLocal() {
   const now = new Date;
-  const nextMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1, 0, 0, 0, 0));
+  const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 0, 0, 0);
   return nextMonth.toISOString();
 }
 function mapPeriodTokens(data) {
@@ -667,14 +731,12 @@ function mapPeriodTokens(data) {
 function createQuotaWindow(used, limit, resetsAt) {
   if (used === undefined)
     return null;
-  const actualLimit = limit === null || limit === undefined ? null : limit;
-  let remaining = null;
-  if (actualLimit !== null) {
-    remaining = Math.max(0, actualLimit - used);
-  }
+  if (limit === null || limit === undefined)
+    return null;
+  const remaining = Math.max(0, limit - used);
   return {
     used,
-    limit: actualLimit,
+    limit,
     remaining,
     resetsAt
   };
@@ -730,9 +792,9 @@ async function fetchSub2api(baseUrl, token, config, timeoutMs = 5000) {
       if (!sub) {
         throw new Error("Subscription mode but no subscription object in response");
       }
-      result.daily = createQuotaWindow(sub.daily_usage_usd, sub.daily_limit_usd, computeNextMidnightUTC());
-      result.weekly = createQuotaWindow(sub.weekly_usage_usd, sub.weekly_limit_usd, computeNextMondayUTC());
-      result.monthly = createQuotaWindow(sub.monthly_usage_usd, sub.monthly_limit_usd, computeFirstOfNextMonthUTC());
+      result.daily = createQuotaWindow(sub.daily_usage_usd, sub.daily_limit_usd, computeNextMidnightLocal());
+      result.weekly = createQuotaWindow(sub.weekly_usage_usd, sub.weekly_limit_usd, computeNextMondayLocal());
+      result.monthly = createQuotaWindow(sub.monthly_usage_usd, sub.monthly_limit_usd, computeFirstOfNextMonthLocal());
       result.resetsAt = computeSoonestReset(result);
     }
     if (data.usage) {
@@ -756,12 +818,12 @@ async function fetchSub2api(baseUrl, token, config, timeoutMs = 5000) {
           used: 0,
           limit: 0,
           remaining: 0,
-          resetsAt: computeNextMidnightUTC()
+          resetsAt: computeNextMidnightLocal()
         },
         weekly: null,
         monthly: null,
         balance: null,
-        resetsAt: computeNextMidnightUTC(),
+        resetsAt: computeNextMidnightLocal(),
         tokenStats: null,
         rateLimit: null
       };
@@ -770,6 +832,44 @@ async function fetchSub2api(baseUrl, token, config, timeoutMs = 5000) {
   }
 }
 
+// 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/providers/claude-relay-service.ts
 function computeWeeklyResetTime(resetDay, resetHour) {
   const now = new Date;
@@ -785,20 +885,19 @@ function computeWeeklyResetTime(resetDay, resetHour) {
 function createQuotaWindow2(used, limit, resetsAt) {
   if (used === undefined)
     return null;
-  const actualLimit = limit && limit > 0 ? limit : null;
-  let remaining = null;
-  if (actualLimit !== null) {
-    remaining = Math.max(0, actualLimit - used);
-  }
+  if (!limit || limit <= 0)
+    return null;
+  const remaining = Math.max(0, limit - used);
   return {
     used,
-    limit: actualLimit,
+    limit,
     remaining,
     resetsAt
   };
 }
 async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = 5000) {
-  const url = `${baseUrl}/apiStats/api/user-stats`;
+  const origin = extractOrigin(baseUrl);
+  const url = `${origin}/apiStats/api/user-stats`;
   const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
   if (resolvedUA) {
     logger.debug(`Using User-Agent: ${resolvedUA}`);
@@ -1100,7 +1199,7 @@ async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs
 
 // src/providers/autodetect.ts
 var detectionCache = new Map;
-function detectProvider(baseUrl, customProviders = {}) {
+function detectProviderFromUrlPattern(baseUrl, customProviders = {}) {
   const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
   for (const [providerId, config] of Object.entries(customProviders)) {
     if (config.urlPatterns && config.urlPatterns.length > 0) {
@@ -1112,25 +1211,71 @@ function detectProvider(baseUrl, customProviders = {}) {
       }
     }
   }
-  if (normalizedUrl.includes("/apistats") || normalizedUrl.includes("relay") || normalizedUrl.includes("/api/user-stats")) {
+  if (normalizedUrl.includes("/apistats") || normalizedUrl.includes("/api/user-stats")) {
     return "claude-relay-service";
   }
   return "sub2api";
 }
-function resolveProvider(baseUrl, providerOverride, customProviders = {}) {
+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 provider = detectProvider(baseUrl, customProviders);
+  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: new Date().toISOString()
+    detectedAt: now
+  });
+  writeProviderDetectionCache(baseUrl, {
+    baseUrl,
+    provider,
+    detectedVia,
+    detectedAt: now,
+    ttlSeconds: PROVIDER_DETECTION_TTL_SECONDS
   });
-  return provider;
 }
 
 // src/providers/index.ts
@@ -1433,10 +1578,10 @@ function renderCountdown(resetsAt, config, clockFormat) {
   if (format === "auto") {
     if (remainingMs < 60000) {
       timeStr = "now";
-    } else if (remainingMs <= 86400000) {
+    } else if (remainingMs <= 604800000) {
       timeStr = formatDuration(remainingMs);
     } else {
-      timeStr = formatWallClock(resetDate, clockFormat);
+      timeStr = formatDateOnly(resetDate);
     }
   } else if (format === "duration") {
     if (remainingMs < 60000) {
@@ -1459,11 +1604,23 @@ function formatDuration(ms) {
     return `${days}d ${remainingHours}h`;
   } else if (hours >= 1) {
     const remainingMinutes = minutes % 60;
-    return `${hours}h${remainingMinutes}m`;
+    return `${hours}h ${remainingMinutes}m`;
   } else {
     return `${minutes}m`;
   }
 }
+function formatDateOnly(date) {
+  const now = new Date;
+  const dayOfWeek = date.toLocaleDateString("en-US", { weekday: "short" });
+  const month = date.toLocaleDateString("en-US", { month: "short" });
+  const dayOfMonth = date.getDate();
+  const isSameMonth = date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth();
+  if (isSameMonth) {
+    return `${dayOfWeek} ${dayOfMonth}`;
+  } else {
+    return `${month} ${dayOfMonth}`;
+  }
+}
 function formatWallClock(date, clockFormat) {
   const now = new Date;
   const dayOfWeek = date.toLocaleDateString("en-US", { weekday: "short" });
@@ -1715,7 +1872,14 @@ function getTerminalWidth() {
   if (process.stdout.columns && process.stdout.columns > 0) {
     return process.stdout.columns;
   }
-  return 80;
+  const colsOverride = process.env["CC_STATUSLINE_COLS"];
+  if (colsOverride) {
+    const parsed = parseInt(colsOverride, 10);
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return 200;
 }
 function computeMaxWidth(termWidth, maxWidthPct) {
   const pct = Math.max(20, Math.min(100, maxWidthPct));
@@ -1756,6 +1920,16 @@ function ansiAwareTruncate(text, maxWidth) {
   }
   return output + "…";
 }
+var COMPONENT_DROP_PRIORITY = [
+  "plan",
+  "tokens",
+  "rateLimit",
+  "monthly",
+  "countdown",
+  "weekly",
+  "daily",
+  "balance"
+];
 
 // src/renderer/index.ts
 var DEFAULT_COMPONENT_ORDER2 = [
@@ -1769,7 +1943,7 @@ var DEFAULT_COMPONENT_ORDER2 = [
 ];
 function renderStatusline(data, config, errorState, cacheAge) {
   const componentOrder = getComponentOrder(config);
-  const renderedComponents = [];
+  const componentMap = new Map;
   for (const componentId of componentOrder) {
     const componentConfig = config.components[componentId];
     if (componentConfig === false) {
@@ -1777,10 +1951,38 @@ function renderStatusline(data, config, errorState, cacheAge) {
     }
     const rendered = renderComponent(componentId, data, componentConfig === true || componentConfig === undefined ? {} : componentConfig, config);
     if (rendered !== null) {
-      renderedComponents.push(rendered);
+      componentMap.set(componentId, rendered);
     }
   }
+  const termWidth = getTerminalWidth();
+  const maxWidth = computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
   const separator = config.display.separator ?? " | ";
+  const activeComponents = new Set(componentMap.keys());
+  let currentWidth = calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge);
+  for (const dropCandidate of COMPONENT_DROP_PRIORITY) {
+    if (dropCandidate === "countdown") {
+      continue;
+    }
+    if (currentWidth <= maxWidth) {
+      break;
+    }
+    if (activeComponents.size <= 1) {
+      break;
+    }
+    if (activeComponents.has(dropCandidate)) {
+      activeComponents.delete(dropCandidate);
+      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) {
     const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
@@ -1797,11 +1999,37 @@ function renderStatusline(data, config, errorState, cacheAge) {
       }
     }
   }
-  const termWidth = getTerminalWidth();
-  const maxWidth = computeMaxWidth(termWidth, config.display.maxWidth ?? 80);
   statusline = ansiAwareTruncate(statusline, maxWidth);
   return statusline;
 }
+function calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge) {
+  const components = [];
+  for (const id of componentOrder) {
+    if (activeComponents.has(id)) {
+      const rendered = componentMap.get(id);
+      if (rendered) {
+        components.push(rendered);
+      }
+    }
+  }
+  let statusline = components.join(separator);
+  if (errorState) {
+    const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
+    if (isTransition) {
+      statusline = renderError(errorState, "with-cache", data.provider, undefined, cacheAge);
+    } else {
+      const hasCache = components.length > 0;
+      const errorMode = hasCache ? "with-cache" : "without-cache";
+      const errorIndicator = renderError(errorState, errorMode, data.provider, undefined, cacheAge);
+      if (hasCache) {
+        statusline = `${statusline} ${errorIndicator}`;
+      } else {
+        statusline = errorIndicator;
+      }
+    }
+  }
+  return visibleLength(statusline);
+}
 function getComponentOrder(config) {
   const explicitOrder = [];
   const explicitSet = new Set;
@@ -1878,7 +2106,7 @@ async function executeCycle(ctx) {
     if (!baseUrl || !authToken) {
       return {
         output: renderError("missing-env", "without-cache"),
-        exitCode: 1,
+        exitCode: 0,
         cacheUpdate: null
       };
     }
@@ -1898,7 +2126,8 @@ async function executeCycle(ctx) {
       ttlSeconds,
       data,
       renderedLine: statusline,
-      configHash
+      configHash,
+      errorState: null
     };
     return {
       output: statusline,
@@ -1921,7 +2150,7 @@ async function executeCycle(ctx) {
       const errorOutput = renderError("network-error", "without-cache", providerId);
       return {
         output: errorOutput,
-        exitCode: 1,
+        exitCode: 0,
         cacheUpdate: null
       };
     }
@@ -1997,7 +2226,7 @@ function uninstallStatusLine() {
 // package.json
 var package_default = {
   name: "cc-api-statusline",
-  version: "0.1.1",
+  version: "0.1.3",
   description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
   type: "module",
   bin: {
@@ -2192,7 +2421,7 @@ async function main() {
   if (envError) {
     const errorOutput = renderError("missing-env", "without-cache");
     process.stdout.write(errorOutput);
-    process.exit(1);
+    process.exit(0);
   }
   const baseUrl = env.baseUrl;
   const authToken = env.authToken;
@@ -2203,14 +2432,15 @@ async function main() {
   const configPath = getConfigPath(args.configPath);
   const configHash = computeConfigHash(configPath);
   logger.debug("Config loaded", { configPath, configHash });
-  const providerId = resolveProvider(baseUrl, env.providerOverride, config.customProviders ?? {});
+  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 });
+  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(1);
+    process.exit(0);
   }
   const cachedEntry = readCache(baseUrl);
   logger.debug("Cache read", {
@@ -2239,12 +2469,17 @@ async function main() {
     outputLength: result.output.length,
     cacheUpdate: !!result.cacheUpdate
   });
+  let output = result.output;
+  if (!output || output.trim().length === 0) {
+    output = "[loading...]";
+    logger.debug("Empty output detected, using fallback");
+  }
   if (isPiped) {
-    const formatted = "\x1B[0m" + result.output.replace(/ /g, " ");
+    const formatted = "\x1B[0m" + output.replace(/ /g, " ");
     process.stdout.write(formatted);
     logger.debug("Output formatted for piped mode (ANSI reset + NBSP)");
   } else {
-    process.stdout.write(result.output);
+    process.stdout.write(output);
     logger.debug("Output written (TTY mode)");
   }
   if (result.cacheUpdate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-api-statusline",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Claude Code statusline tool that polls API usage from third-party proxy backends",
   "type": "module",
   "bin": {