cc-api-statusline 0.1.2 → 0.1.4

package/dist/cc-api-statusline.js

@@ -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";
@@ -638,7 +697,7 @@ function detectClaudeVersion() {
   }
 }
 
-// src/providers/sub2api.ts
+// src/services/time.ts
 function computeNextMidnightLocal() {
   const now = new Date;
   const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 0, 0);
@@ -656,6 +715,8 @@ function computeFirstOfNextMonthLocal() {
   const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 0, 0, 0);
   return nextMonth.toISOString();
 }
+
+// src/providers/sub2api.ts
 function mapPeriodTokens(data) {
   if (!data)
     return null;
@@ -672,14 +733,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
   };
@@ -775,6 +834,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;
@@ -790,20 +887,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}`);
@@ -836,16 +932,18 @@ async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = 5000)
     tokenStats: null,
     rateLimit: null
   };
-  result.daily = createQuotaWindow2(limits.currentDailyCost, limits.dailyCostLimit, null);
+  result.daily = createQuotaWindow2(limits.currentDailyCost, limits.dailyCostLimit, computeNextMidnightLocal());
   if (limits.weeklyResetDay !== undefined && limits.weeklyResetHour !== undefined) {
     const weeklyResetsAt = computeWeeklyResetTime(limits.weeklyResetDay, limits.weeklyResetHour);
     result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, weeklyResetsAt);
   } else {
-    result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, null);
+    result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, computeNextMondayLocal());
   }
   result.monthly = null;
   if (limits.windowEndTime) {
     result.resetsAt = new Date(limits.windowEndTime).toISOString();
+  } else {
+    result.resetsAt = computeSoonestReset(result);
   }
   if (data.usage?.total) {
     const total = data.usage.total;
@@ -1105,7 +1203,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) {
@@ -1117,25 +1215,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
@@ -2086,7 +2230,7 @@ function uninstallStatusLine() {
 // package.json
 var package_default = {
   name: "cc-api-statusline",
-  version: "0.1.2",
+  version: "0.1.4",
   description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
   type: "module",
   bin: {
@@ -2292,9 +2436,10 @@ 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");

package/package.json

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