@fyeeme/pi-statusline 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.2] - 2025-07-15
+
+### Fixed
+
+- `getCachedUsage` crash when TTL expires and model provider has no registered UsageProvider (TypeError on null)
+- `scanWeeklyTokens` UTC/local timezone mismatch: file date parsing now uses local timezone to match `startOfCurrentWeekLocal`
+- Unhandled rejection in `refreshUsage` fire-and-forget callers: added catch-all error handler
+
+### Changed
+
+- Background usage refresh now deduplicates concurrent TTL-expired callers via memoized `refreshInFlight` promise
+- Weekly token scan results cached for 1 minute to reduce redundant filesystem I/O
+
+### Removed
+
+- MCP server status segment from footer and its event listeners (`mcp:status`/`mcp:disconnect`): no pi version emits these events
+
+## [1.0.1] - 2026-06-19
+
+### Fixed
+
+- ZAI weekly token count for plans without a `unit:6` weekly quota now comes from the backend `model-usage` API for the current natural week (Mon 00:00 UTC → now) instead of scanning local session files, so it matches the backend's per-week tally. Footer label changed from `7d:` to `W:` to reflect the natural-week window.
+
+### Changed
+
+- Natural-week window (DeepSeek local scan and ZAI fallback) now uses the host's local timezone instead of UTC, so "this week" matches the user's expectation. Both providers share the same boundary via `startOfCurrentWeekLocal`.
+
+### Removed
+
+- `quota/` directory (`QuotaCalculator` and its DeepSeek/ZAI implementations) and the `quotaCalculator` field on `UsageProvider`. These were never invoked at runtime; the live logic lives in the providers directly.
+
 ## [1.0.1] - 2026-06-19
 
 ### Fixed

package/cache.ts

@@ -12,9 +12,13 @@ interface CacheEntry {
 const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 
 let usageCache: CacheEntry | null = null;
+let refreshInFlight: Promise<ProviderUsageResult> | null = null;
+let refreshGeneration = 0;
 
 export function resetUsageCache(): void {
 	usageCache = null;
+	refreshInFlight = null;
+	refreshGeneration += 1;
 }
 
 export function getUsageCache(): CacheEntry | null {
@@ -33,13 +37,22 @@ export async function refreshUsage(
 		return null;
 	}
 
-	const result = await provider.fetchUsage(modelRegistry, model);
-	if (result) {
-		usageCache = { result, fetchedAt: Date.now() };
-	} else {
-		usageCache = null;
+	const gen = ++refreshGeneration;
+	try {
+		const result = await provider.fetchUsage(modelRegistry, model);
+		// Drop stale responses from older generations
+		if (gen !== refreshGeneration) return usageCache?.result ?? null;
+		if (result) {
+			usageCache = { result, fetchedAt: Date.now() };
+		} else {
+			usageCache = null;
+		}
+		return result;
+	} catch {
+		// Total catch: fire-and-forget callers must never see an unhandled rejection
+		if (gen === refreshGeneration) usageCache = null;
+		return null;
 	}
-	return result;
 }
 
 export function getUsageCacheAge(): number | null {
@@ -53,11 +66,22 @@ export function getCachedUsage(
 	lastModel: ExtensionContext["model"] | undefined,
 ): ProviderUsageResult {
 	if (!usageCache) return null;
-	if (Date.now() - usageCache.fetchedAt > CACHE_TTL_MS) {
-		// TTL expired: return stale data but trigger background refresh
+	// Capture local snapshot before triggering background refresh: refreshUsage
+	// may synchronously set usageCache = null when the provider is not found,
+	// which would make the eventual `return cache.result` throw on null.
+	const cache = usageCache;
+	if (Date.now() - cache.fetchedAt > CACHE_TTL_MS) {
+		// TTL expired: return stale data but trigger background refresh.
+		// Memoize inflight promise so concurrent callers share one fetch.
 		if (lastCtx && lastModel) {
-			void refreshUsage(providers, lastCtx.modelRegistry, lastModel);
+			if (!refreshInFlight) {
+				const promise = refreshUsage(providers, lastCtx.modelRegistry, lastModel);
+				refreshInFlight = promise;
+				promise.finally(() => {
+					if (refreshInFlight === promise) refreshInFlight = null;
+				});
+			}
 		}
 	}
-	return usageCache.result;
+	return cache.result;
 }

package/footer.ts

@@ -75,7 +75,6 @@ export function buildStatLine(
 	providers: Record<string, UsageProvider>,
 	getElapsedSec: () => number,
 	lastTps: number,
-	mcpStatuses: Map<string, { connected: boolean; toolCount: number }>,
 ): string {
 	const mods: string[] = [];
 
@@ -131,15 +130,8 @@ export function buildStatLine(
 		if (t.length) mods.push(t.join(" "));
 	}
 
-	// MCP: MCP:2(15) or MCP:0
-	{
-		const entries = Array.from(mcpStatuses.entries());
-		if (entries.length) {
-			const connected = entries.filter(([, s]) => s.connected).length;
-			const tools = entries.reduce((sum, [, s]) => sum + s.toolCount, 0);
-			mods.push(connected > 0 ? `MCP:${connected}(${tools})` : "MCP:0");
-		}
-	}
+	// MCP status: no pi version emits mcp:status/mcp:disconnect events.
+	// The segment is disabled until a documented event source exists.
 
 	return mods.join(" · ");
 }

package/index.ts

@@ -47,8 +47,6 @@ let lastElapsedSec = 0;
 let lastTps = 0;
 let currencyOverride: "¥" | "$" | undefined = undefined;
 
-const mcpStatuses = new Map<string, { connected: boolean; toolCount: number }>();
-
 const tokenCalculator = new SessionTokenUsageCalculator(() => currencyOverride);
 
 // ---------------------------------------------------------------------------
@@ -99,14 +97,6 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	pi.events.on("mcp:status", (raw) => {
-		const data = raw as { id: string; connected: boolean; toolCount: number };
-		mcpStatuses.set(data.id, { connected: data.connected, toolCount: data.toolCount });
-	});
-	pi.events.on("mcp:disconnect", (raw) => {
-		mcpStatuses.delete((raw as { id: string }).id);
-	});
-
 	// ---- /status-debug ----
 	pi.registerCommand("status-debug", {
 		description: "Dump session stats to /tmp/pi-status-debug.log + console.error",
@@ -235,7 +225,7 @@ export default function (pi: ExtensionAPI) {
 
 					// Line 1: tokens + cost + provider usage + context + elapsed + tps + mcp
 					lines.push(truncateToWidth(
-						dim(buildStatLine(stats, cu, providerResult, providers, getElapsedSec, lastTps, mcpStatuses)),
+						dim(buildStatLine(stats, cu, providerResult, providers, getElapsedSec, lastTps)),
 						width,
 						dim("..."),
 					));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fyeeme/pi-statusline",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Rich custom status bar for pi with token usage, cost, DeepSeek balance, context window, timing, and MCP connection status.",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,6 @@
   "files": [
     "*.ts",
     "providers/*.ts",
-    "quota/*.ts",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/providers/deepseek.ts

@@ -1,13 +1,10 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { DeepSeekResult, ProviderUsageResult } from "../types.ts";
 import type { UsageProvider } from "./types.ts";
-import type { QuotaCalculator } from "../quota/types.ts";
-import { DeepSeekQuotaCalculator } from "../quota/deepseek.ts";
 import { scanWeeklyTokens } from "../session-scanner.ts";
 import { fmt } from "../footer.ts";
 
 export class DeepSeekUsageProvider implements UsageProvider {
-	quotaCalculator: QuotaCalculator = new DeepSeekQuotaCalculator();
 
 	async fetchUsage(
 		modelRegistry: ExtensionContext["modelRegistry"],

package/providers/types.ts

@@ -1,6 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { ProviderUsageResult } from "../types.ts";
-import type { QuotaCalculator } from "../quota/types.ts";
 
 export interface UsageProvider {
 	fetchUsage(
@@ -9,5 +8,4 @@ export interface UsageProvider {
 	): Promise<ProviderUsageResult>;
 	formatForFooter(result: NonNullable<ProviderUsageResult>, sessionCost: number, currency: string): string;
 	debugDump(result: NonNullable<ProviderUsageResult>, w: (s: string) => void): void;
-	quotaCalculator: QuotaCalculator;
 }

package/providers/zai.ts

@@ -1,10 +1,8 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { ZaiResult, ProviderUsageResult } from "../types.ts";
 import type { UsageProvider } from "./types.ts";
-import type { QuotaCalculator } from "../quota/types.ts";
-import { ZaiQuotaCalculator } from "../quota/zai.ts";
 import { fmt, formatCountdown, formatWeeklyCountdown } from "../footer.ts";
-import { scanWeeklyTokens } from "../session-scanner.ts";
+import { startOfCurrentWeekLocal, startOfNextWeekLocal } from "../week.ts";
 
 /** Check if the provider name is a ZAI/GLM variant. */
 function isZaiProvider(provider: string): boolean {
@@ -12,7 +10,6 @@ function isZaiProvider(provider: string): boolean {
 }
 
 export class ZaiUsageProvider implements UsageProvider {
-	quotaCalculator: QuotaCalculator = new ZaiQuotaCalculator();
 
 	async fetchUsage(
 		modelRegistry: ExtensionContext["modelRegistry"],
@@ -75,16 +72,15 @@ export class ZaiUsageProvider implements UsageProvider {
 				const cycleStart = weeklyResetAt - 7 * 24 * 60 * 60 * 1000;
 				weeklyTokens = await this.fetchCycleUsage(origin, headers, cycleStart, now);
 			} else {
-				// No unit:6 — natural week fallback, same as DeepSeek
+				// No unit:6 — natural week fallback. Fetch real usage from the
+				// model-usage API for the current natural week (Mon 00:00 local → now)
+				// so the figure matches the backend's per-week tally instead of
+				// only counting tokens from local session files.
 				isNaturalWeek = true;
-				weeklyTokens = scanWeeklyTokens(model.provider);
-
 				const d = new Date(now);
-				const dayOfWeek = d.getUTCDay();
-				const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
-				weeklyResetAt = Date.UTC(
-					d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + daysUntilMonday, 0, 0, 0, 0,
-				);
+				const cycleStart = startOfCurrentWeekLocal(d);
+				weeklyResetAt = startOfNextWeekLocal(d);
+				weeklyTokens = await this.fetchCycleUsage(origin, headers, cycleStart, now);
 			}
 
 			return {
@@ -114,7 +110,7 @@ export class ZaiUsageProvider implements UsageProvider {
 		// Weekly quota
 		if (zai.isNaturalWeek) {
 			if (zai.weeklyTokens > 0) {
-				parts.push(`7d:${fmt(zai.weeklyTokens)}`);
+				parts.push(`W:${fmt(zai.weeklyTokens)}`);
 			}
 		} else if (zai.weeklyTokens > 0 || zai.weeklyPct > 0) {
 			const weeklyCountdown = formatWeeklyCountdown(zai.weeklyResetAt);

package/session-scanner.ts

@@ -1,16 +1,25 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { startOfCurrentWeekLocal } from "./week.ts";
+
+const SCAN_CACHE_TTL_MS = 60_000; // 1 minute
+let scanCache: { providerName: string; sessionsDir: string; weekStartMs: number; total: number; fetchedAt: number } | null = null;
 
 export function scanWeeklyTokens(providerName: string): number {
 	const sessionsDir = join(getAgentDir(), "sessions");
-	const now = new Date();
-	// Natural week: Monday 00:00 UTC
-	const dayOfWeek = now.getUTCDay();
-	const mondayOffset = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
-	const weekStart = new Date(
-		Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - mondayOffset, 0, 0, 0, 0),
-	);
+	const weekStartMs = startOfCurrentWeekLocal();
+
+	// Return cached result if still valid for the same week window and sessions dir
+	if (
+		scanCache &&
+		scanCache.providerName === providerName &&
+		scanCache.sessionsDir === sessionsDir &&
+		scanCache.weekStartMs === weekStartMs &&
+		Date.now() - scanCache.fetchedAt < SCAN_CACHE_TTL_MS
+	) {
+		return scanCache.total;
+	}
 
 	let total = 0;
 
@@ -28,8 +37,8 @@ export function scanWeeklyTokens(providerName: string): number {
 			for (const fname of files) {
 				if (!fname.endsWith(".jsonl")) continue;
 				try {
-					const fileDate = new Date(fname.slice(0, 10) + "T00:00:00Z");
-					if (fileDate < weekStart) continue;
+					const fileDate = new Date(fname.slice(0, 10) + "T00:00:00");
+					if (fileDate.getTime() < weekStartMs) continue;
 				} catch {
 					continue;
 				}
@@ -60,5 +69,6 @@ export function scanWeeklyTokens(providerName: string): number {
 		// sessions dir doesn't exist or is unreadable
 	}
 
+	scanCache = { providerName, sessionsDir, weekStartMs, total, fetchedAt: Date.now() };
 	return total;
 }

package/week.ts

@@ -0,0 +1,30 @@
+/**
+ * Natural-week window helpers.
+ *
+ * Both DeepSeek (local session scan) and ZAI (backend usage API) derive their
+ * weekly window from here, so the two providers always agree on the same
+ * natural-week boundary — Monday 00:00 in the host's local timezone.
+ *
+ * Note: UTC was used previously; local timezone is now intentional so the
+ * figures line up with how users perceive "this week".
+ */
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Epoch ms of the start of the current natural week (this Monday 00:00 local).
+ * `now` is overridable for testing.
+ */
+export function startOfCurrentWeekLocal(now: Date = new Date()): number {
+	const dayOfWeek = now.getDay(); // 0=Sun .. 6=Sat
+	const mondayOffset = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+	return new Date(
+		now.getFullYear(), now.getMonth(), now.getDate() - mondayOffset,
+		0, 0, 0, 0,
+	).getTime();
+}
+
+/** Epoch ms of the start of the next natural week (next Monday 00:00 local). */
+export function startOfNextWeekLocal(now: Date = new Date()): number {
+	return startOfCurrentWeekLocal(now) + 7 * DAY_MS;
+}

package/quota/deepseek.ts

@@ -1,31 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { QuotaCalculator, QuotaInfo, WeeklyQuota } from "./types.ts";
-import { scanWeeklyTokens } from "../session-scanner.ts";
-
-export class DeepSeekQuotaCalculator implements QuotaCalculator {
-	async calculate(
-		_modelRegistry: ExtensionContext["modelRegistry"],
-		_model: ExtensionContext["model"],
-	): Promise<QuotaInfo> {
-		const weeklyTokens = scanWeeklyTokens("deepseek");
-
-		// Next Monday 00:00 UTC
-		const now = new Date();
-		const dayOfWeek = now.getUTCDay();
-		const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
-		const nextMonday = new Date(
-			Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0, 0),
-		);
-
-		const weekly: WeeklyQuota = {
-			usedTokens: weeklyTokens,
-			resetAt: nextMonday.getTime(),
-			crossesNaturalWeek: false,
-		};
-
-		return {
-			rolling: null,
-			weekly,
-		};
-	}
-}

package/quota/types.ts

@@ -1,34 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-/** Rolling quota window (e.g. ZAI 5-hour token quota) */
-export interface RollingQuota {
-	/** Usage percentage 0–100 */
-	usedPct: number;
-	/** Epoch ms when the window resets */
-	resetAt: number;
-}
-
-/** Weekly subscription quota */
-export interface WeeklyQuota {
-	/** Total tokens used in the subscription week */
-	usedTokens: number;
-	/** Epoch ms when the subscription week resets */
-	resetAt: number;
-	/** Whether resetAt crosses a natural week boundary */
-	crossesNaturalWeek: boolean;
-	/** Usage percentage from unit:6 TOKENS_LIMIT (0 if natural week) */
-	weeklyPct?: number;
-}
-
-/** Provider-specific quota. Fields are null when the provider doesn't support them. */
-export interface QuotaInfo {
-	rolling: RollingQuota | null;
-	weekly: WeeklyQuota | null;
-}
-
-export interface QuotaCalculator {
-	calculate(
-		modelRegistry: ExtensionContext["modelRegistry"],
-		model: ExtensionContext["model"],
-	): Promise<QuotaInfo>;
-}

package/quota/zai.ts

@@ -1,90 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { QuotaCalculator, QuotaInfo, WeeklyQuota } from "./types.ts";
-import { scanWeeklyTokens } from "../session-scanner.ts";
-
-export class ZaiQuotaCalculator implements QuotaCalculator {
-	async calculate(
-		modelRegistry: ExtensionContext["modelRegistry"],
-		model: ExtensionContext["model"],
-	): Promise<QuotaInfo> {
-		if (!model || (model.provider !== "zai" && model.provider !== "zai-coding-cn")) {
-			return { rolling: null, weekly: null };
-		}
-
-		const apiKey = await modelRegistry.getApiKeyForProvider(model.provider);
-		if (!apiKey) return { rolling: null, weekly: null };
-
-		const defaultOrigin = model.provider === "zai-coding-cn"
-			? "https://open.bigmodel.cn"
-			: "https://api.z.ai";
-		let origin = defaultOrigin;
-		try { origin = new URL(model.baseUrl ?? defaultOrigin).origin; } catch { /* use default */ }
-
-		const headers: Record<string, string> = {
-			Authorization: apiKey,
-			"Accept-Language": "en-US,en",
-			"Content-Type": "application/json",
-		};
-
-		let rolling: QuotaInfo["rolling"] = null;
-		let weekly: QuotaInfo["weekly"] = null;
-
-		try {
-			const quotaRes = await fetch(`${origin}/api/monitor/usage/quota/limit`, {
-				headers,
-				signal: AbortSignal.timeout(5000),
-			});
-			if (quotaRes.ok) {
-				const quotaData = (await quotaRes.json()) as {
-					data?: {
-						limits?: Array<{
-							type: string;
-							unit?: number;
-							percentage?: number;
-							nextResetTime?: number;
-						}>;
-					};
-				};
-
-				const limits = quotaData.data?.limits ?? [];
-				const fiveHourLimit = limits.find((l) => l.type === "TOKENS_LIMIT" && l.unit === 3);
-				const weeklyLimit = limits.find((l) => l.type === "TOKENS_LIMIT" && l.unit === 6);
-
-				if (fiveHourLimit) {
-					rolling = {
-						usedPct: fiveHourLimit.percentage ?? 0,
-						resetAt: fiveHourLimit.nextResetTime ?? 0,
-					};
-				}
-
-				if (weeklyLimit && weeklyLimit.nextResetTime && weeklyLimit.nextResetTime > 0) {
-					// unit:6 — weekly quota from API
-					weekly = {
-						usedTokens: 0, // actual token count fetched separately by provider
-						resetAt: weeklyLimit.nextResetTime ?? 0,
-						crossesNaturalWeek: true,
-						weeklyPct: weeklyLimit.percentage ?? 0,
-					};
-				} else {
-					// No unit:6 — natural week fallback
-					const weeklyTokens = scanWeeklyTokens(model.provider);
-					const now = new Date();
-					const dayOfWeek = now.getUTCDay();
-					const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
-					const nextMonday = new Date(
-						Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0, 0),
-					);
-					weekly = {
-						usedTokens: weeklyTokens,
-						resetAt: nextMonday.getTime(),
-						crossesNaturalWeek: false,
-					};
-				}
-			}
-		} catch {
-			// quota unavailable
-		}
-
-		return { rolling, weekly };
-	}
-}