pi-crew 0.9.26 → 0.9.28

package/src/extension/crew-vibes/provider-usage.ts

@@ -0,0 +1,396 @@
+/**
+ * Self-contained provider rate-limit usage fetcher for crew-vibes.
+ *
+ * Reads credentials from `~/.pi/agent/auth.json` (plus env overrides) and
+ * queries the Anthropic OAuth usage endpoint (primary) and the Copilot
+ * internal quota endpoint (secondary). All failure paths return `null`
+ * gracefully so headless / credential-less sessions never crash.
+ *
+ * No external dependencies — only Node.js built-ins (fs, path, os).
+ */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface ProviderUsage {
+	providerName: string;
+	fiveHourPercent: number;
+	fiveHourResetAt: string | null;
+	weeklyPercent: number;
+	weeklyResetAt: string | null;
+	copilotMonthlyPercent?: number;
+}
+
+/** AbortController + setTimeout helper. Always clears the timer. */
+function withTimeout<T>(ms: number, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), ms);
+	return fn(controller.signal).finally(() => clearTimeout(timeoutId));
+}
+
+// ---------------------------------------------------------------------------
+// Credential loading
+// ---------------------------------------------------------------------------
+
+function piAuthPath(): string {
+	return join(homedir(), ".pi", "agent", "auth.json");
+}
+
+/** Load the Anthropic OAuth access token from auth.json or env override. */
+export function loadAnthropicToken(): string | undefined {
+	const envToken = process.env.ANTHROPIC_OAUTH_TOKEN?.trim();
+	if (envToken) return envToken;
+	try {
+		const data = JSON.parse(readFileSync(piAuthPath(), "utf8")) as {
+			anthropic?: { access?: string };
+		};
+		const token = data.anthropic?.access;
+		return typeof token === "string" && token.length > 0 ? token : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Load the z.ai API key from env or auth.json. */
+export function loadZaiToken(): string | undefined {
+	const envKey = process.env.ZAI_API_KEY?.trim() || process.env.Z_AI_API_KEY?.trim();
+	if (envKey) return envKey;
+	try {
+		const data = JSON.parse(readFileSync(piAuthPath(), "utf8")) as {
+			"z-ai"?: { access?: string; key?: string };
+			zai?: { access?: string; key?: string };
+		};
+		const key = data["z-ai"]?.access || data["z-ai"]?.key || data.zai?.access || data.zai?.key;
+		return typeof key === "string" && key.length > 0 ? key : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Load the Minimax API key from env or auth.json. */
+export function loadMinimaxToken(): string | undefined {
+	const envKey = process.env.MINIMAX_API_KEY?.trim();
+	if (envKey) return envKey;
+	try {
+		const data = JSON.parse(readFileSync(piAuthPath(), "utf8")) as {
+			minimax?: { key?: string };
+		};
+		const key = data.minimax?.key;
+		return typeof key === "string" && key.length > 0 ? key : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Copilot host entry keys used by the legacy GitHub Copilot CLI. */
+type CopilotHostEntry = {
+	oauth_token?: string;
+	user_token?: string;
+	github_token?: string;
+	token?: string;
+};
+
+const COPILOT_TOKEN_KEYS: Array<keyof CopilotHostEntry> = ["oauth_token", "user_token", "github_token", "token"];
+
+function tokenFromHostEntry(entry: CopilotHostEntry | undefined): string | undefined {
+	if (!entry) return undefined;
+	for (const key of COPILOT_TOKEN_KEYS) {
+		const value = entry[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+/** Scan legacy Copilot hosts.json locations for a usable token. */
+function loadLegacyCopilotToken(): string | undefined {
+	const configHome = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+	const candidates = [join(configHome, "github-copilot", "hosts.json"), join(homedir(), ".github-copilot", "hosts.json")];
+	for (const hostsPath of candidates) {
+		try {
+			const data = JSON.parse(readFileSync(hostsPath, "utf8")) as Record<string, CopilotHostEntry>;
+			if (!data || typeof data !== "object") continue;
+			const normalized: Record<string, CopilotHostEntry> = {};
+			for (const [host, entry] of Object.entries(data)) {
+				normalized[host.toLowerCase()] = entry;
+			}
+			const preferred = tokenFromHostEntry(normalized["github.com"]) ?? tokenFromHostEntry(normalized["api.github.com"]);
+			if (preferred) return preferred;
+			for (const entry of Object.values(normalized)) {
+				const token = tokenFromHostEntry(entry);
+				if (token) return token;
+			}
+		} catch {
+			// Ignore parse / read errors — try next path
+		}
+	}
+	return undefined;
+}
+
+/** Load the Copilot token from auth.json, env vars, then legacy locations. */
+export function loadCopilotToken(): string | undefined {
+	const envToken = (process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN || "").trim();
+	if (envToken) return envToken;
+	try {
+		const data = JSON.parse(readFileSync(piAuthPath(), "utf8")) as {
+			"github-copilot"?: { refresh?: string; access?: string };
+		};
+		const piToken = data["github-copilot"]?.refresh || data["github-copilot"]?.access;
+		if (typeof piToken === "string" && piToken.length > 0) return piToken;
+	} catch {
+		// Ignore parse / read errors
+	}
+	return loadLegacyCopilotToken();
+}
+
+// ---------------------------------------------------------------------------
+// Provider fetches
+// ---------------------------------------------------------------------------
+
+/** Anthropic OAuth usage response shape (subset we consume). */
+type AnthropicUsageResponse = {
+	five_hour?: { utilization?: number; resets_at?: string };
+	seven_day?: { utilization?: number; resets_at?: string };
+};
+
+async function fetchAnthropicUsage(
+	token: string,
+): Promise<Pick<ProviderUsage, "fiveHourPercent" | "weeklyPercent" | "fiveHourResetAt" | "weeklyResetAt">> {
+	const data = await withTimeout(10000, async (signal) => {
+		const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"anthropic-beta": "oauth-2025-04-20",
+			},
+			signal,
+		});
+		if (!res.ok) throw new Error(`anthropic usage HTTP ${res.status}`);
+		return (await res.json()) as AnthropicUsageResponse;
+	});
+	return {
+		fiveHourPercent: data.five_hour?.utilization ?? 0,
+		weeklyPercent: data.seven_day?.utilization ?? 0,
+		fiveHourResetAt: data.five_hour?.resets_at ?? null,
+		weeklyResetAt: data.seven_day?.resets_at ?? null,
+	};
+}
+
+/** Copilot internal user quota response shape (subset we consume). */
+type CopilotUserResponse = {
+	quota_snapshots?: {
+		premium_interactions?: { percent_remaining?: number };
+	};
+};
+
+async function fetchCopilotMonthlyPercent(token: string): Promise<number | undefined> {
+	const data = await withTimeout(10000, async (signal) => {
+		const res = await fetch("https://api.github.com/copilot_internal/user", {
+			headers: {
+				Authorization: `token ${token}`,
+				"Editor-Version": "vscode/1.96.2",
+				"User-Agent": "GitHubCopilotChat/0.26.7",
+				"X-Github-Api-Version": "2025-04-01",
+				Accept: "application/json",
+			},
+			signal,
+		});
+		if (!res.ok) throw new Error(`copilot user HTTP ${res.status}`);
+		return (await res.json()) as CopilotUserResponse;
+	});
+	const percentRemaining = data.quota_snapshots?.premium_interactions?.percent_remaining;
+	if (typeof percentRemaining !== "number") return undefined;
+	return Math.max(0, 100 - percentRemaining);
+}
+
+/** z.ai quota limit response shape. */
+type ZaiLimit = {
+	type?: string;
+	percentage?: number;
+	nextResetTime?: string;
+};
+type ZaiUsageResponse = {
+	success?: boolean;
+	code?: number;
+	msg?: string;
+	data?: { limits?: ZaiLimit[] };
+};
+
+async function fetchZaiUsage(token: string): Promise<ProviderUsage> {
+	const data = await withTimeout(10000, async (signal) => {
+		const res = await fetch("https://api.z.ai/api/monitor/usage/quota/limit", {
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				Accept: "application/json",
+			},
+			signal,
+		});
+		if (!res.ok) throw new Error(`z.ai usage HTTP ${res.status}`);
+		return (await res.json()) as ZaiUsageResponse;
+	});
+	if (!data.success || data.code !== 200) throw new Error(data.msg || "z.ai API error");
+
+	const limits = data.data?.limits ?? [];
+	let tokensPercent = 0;
+	let monthlyPercent = 0;
+	let tokensResetAt: string | null = null;
+	let monthlyResetAt: string | null = null;
+
+	for (const limit of limits) {
+		const pct = limit.percentage ?? 0;
+		// nextResetTime from z.ai is epoch ms (number) — convert to ISO string
+		const resetIso =
+			typeof limit.nextResetTime === "number"
+				? new Date(limit.nextResetTime).toISOString()
+				: typeof limit.nextResetTime === "string"
+					? limit.nextResetTime
+					: null;
+
+		if (limit.type === "TOKENS_LIMIT") {
+			tokensPercent = pct;
+			tokensResetAt = resetIso;
+		} else if (limit.type === "TIME_LIMIT") {
+			monthlyPercent = pct;
+			monthlyResetAt = resetIso;
+		}
+	}
+
+	return {
+		providerName: "z.ai",
+		fiveHourPercent: tokensPercent,
+		fiveHourResetAt: tokensResetAt,
+		weeklyPercent: monthlyPercent,
+		weeklyResetAt: monthlyResetAt,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Cache + public entry point
+// ---------------------------------------------------------------------------
+
+let cachedUsage: ProviderUsage | null = null;
+let cachedAt = 0;
+
+/** Reset the module-level cache (used by tests and on session restart). */
+export function clearProviderUsageCache(): void {
+	cachedUsage = null;
+	cachedAt = 0;
+}
+
+/** Minimax token plan remains response shape. */
+type MinimaxModelRemain = {
+	model_name?: string;
+	current_interval_remaining_percent?: number;
+	current_weekly_remaining_percent?: number;
+	end_time?: number;
+	weekly_end_time?: number;
+};
+type MinimaxUsageResponse = {
+	model_remains?: MinimaxModelRemain[];
+	base_resp?: { status_code?: number; status_msg?: string };
+};
+
+async function fetchMinimaxUsage(token: string): Promise<ProviderUsage> {
+	const data = await withTimeout(10000, async (signal) => {
+		const res = await fetch("https://www.minimax.io/v1/token_plan/remains", {
+			headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+			signal,
+		});
+		if (!res.ok) throw new Error(`minimax usage HTTP ${res.status}`);
+		return (await res.json()) as MinimaxUsageResponse;
+	});
+	if (data.base_resp?.status_code !== 0) throw new Error(data.base_resp?.status_msg || "minimax API error");
+
+	// Find the "general" model (text/chat). Fall back to first model.
+	const models = data.model_remains ?? [];
+	const general = models.find((m) => m.model_name === "general") ?? models[0];
+	if (!general) throw new Error("minimax: no model data");
+
+	// remaining_percent → used percent
+	const intervalUsed = 100 - (general.current_interval_remaining_percent ?? 100);
+	const weeklyUsed = 100 - (general.current_weekly_remaining_percent ?? 100);
+
+	const intervalReset = typeof general.end_time === "number" ? new Date(general.end_time).toISOString() : null;
+	const weeklyReset = typeof general.weekly_end_time === "number" ? new Date(general.weekly_end_time).toISOString() : null;
+
+	return {
+		providerName: "Minimax",
+		fiveHourPercent: intervalUsed,
+		fiveHourResetAt: intervalReset,
+		weeklyPercent: weeklyUsed,
+		weeklyResetAt: weeklyReset,
+	};
+}
+
+/** Providers that have a quota API. */
+const QUOTA_PROVIDERS = new Set(["anthropic", "minimax", "minimax-cn", "zai", "github-copilot"]);
+
+/** Check if a provider supports quota checking. */
+export function providerSupportsQuota(provider: string): boolean {
+	return QUOTA_PROVIDERS.has(provider);
+}
+
+/** Fetch usage for a SPECIFIC provider. Returns null if not supported. */
+async function fetchForProvider(provider: string): Promise<ProviderUsage | null> {
+	switch (provider) {
+		case "anthropic": {
+			const token = loadAnthropicToken();
+			if (!token) return null;
+			const base = await fetchAnthropicUsage(token);
+			return { providerName: "Claude", ...base };
+		}
+		case "minimax":
+		case "minimax-cn": {
+			const token = loadMinimaxToken();
+			if (!token) return null;
+			return await fetchMinimaxUsage(token);
+		}
+		case "zai": {
+			const token = loadZaiToken();
+			if (!token) return null;
+			const usage = await fetchZaiUsage(token);
+			usage.providerName = "z.ai";
+			return usage;
+		}
+		case "github-copilot": {
+			const token = loadCopilotToken();
+			if (!token) return null;
+			const pct = await fetchCopilotMonthlyPercent(token);
+			if (pct === undefined) return null;
+			return {
+				providerName: "Copilot",
+				fiveHourPercent: 0,
+				fiveHourResetAt: null,
+				weeklyPercent: pct,
+				weeklyResetAt: null,
+				copilotMonthlyPercent: pct,
+			};
+		}
+		default:
+			return null;
+	}
+}
+
+/**
+ * Fetch provider rate-limit usage for the current model's provider.
+ * Returns `null` when provider has no quota API or no credentials.
+ */
+export async function fetchProviderUsage(maxAgeMs = 300000, provider?: string): Promise<ProviderUsage | null> {
+	if (!provider || !QUOTA_PROVIDERS.has(provider)) {
+		cachedUsage = null;
+		return null;
+	}
+	if (cachedUsage !== null && Date.now() - cachedAt < maxAgeMs) {
+		return cachedUsage;
+	}
+	try {
+		const usage = await fetchForProvider(provider);
+		if (usage) {
+			cachedUsage = usage;
+			cachedAt = Date.now();
+		}
+		return usage;
+	} catch {
+		return null;
+	}
+}

package/src/extension/crew-vibes/render.ts

@@ -0,0 +1,206 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CrewTheme } from "../../ui/theme-adapter.ts";
+import {
+	CAPACITY_STATUS_ID,
+	type CapacityConfig,
+	type CrewVibesConfig,
+	capacityIcons,
+	PROVIDER_STATUS_ID,
+	SPEED_STATUS_ID,
+	type SpeedConfig,
+	type TokenDisplay,
+} from "./config.ts";
+import { capacityIndex, crewFrames, isDangerStage } from "./figures.ts";
+
+export type CapacityUsage = {
+	tokens: number | null;
+	percent: number | null;
+};
+
+export function formatCount(value: number): string {
+	if (value < 1000) return value.toString();
+	if (value < 10_000) return `${(value / 1000).toFixed(1)}k`;
+	if (value < 1_000_000) return `${Math.round(value / 1000)}k`;
+	if (value < 10_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+	return `${Math.round(value / 1_000_000)}M`;
+}
+
+function asCrewTheme(theme: unknown): CrewTheme | undefined {
+	if (theme && typeof theme === "object" && typeof (theme as CrewTheme).fg === "function") {
+		return theme as CrewTheme;
+	}
+	return undefined;
+}
+
+export function getCapacityUsage(ctx: ExtensionContext): CapacityUsage {
+	const fn = (ctx as { getContextUsage?: () => { tokens?: number; percent?: number } | null }).getContextUsage;
+	const usage = typeof fn === "function" ? fn.call(ctx) : null;
+	return {
+		tokens: typeof usage?.tokens === "number" && Number.isFinite(usage.tokens) ? usage.tokens : null,
+		percent: typeof usage?.percent === "number" && Number.isFinite(usage.percent) ? usage.percent : null,
+	};
+}
+
+export function formatSpeed(config: SpeedConfig, speed: number | null): string {
+	return speed === null ? `-- ${config.label}` : `${speed.toFixed(1)} ${config.label}`;
+}
+
+export function renderSpeedFooter(theme: CrewTheme | undefined, config: SpeedConfig, speed: number | null): string {
+	const value = speed === null ? "--" : speed.toFixed(1);
+	const valueTone = speed === null ? "dim" : "accent";
+	const styled = theme ? `${theme.fg(valueTone, value)} ${theme.fg("dim", config.label)}` : `${value} ${config.label}`;
+	return styled;
+}
+
+export function renderWorkingMessage(theme: CrewTheme | undefined, config: SpeedConfig, speed: number | null): string {
+	const left = "Working";
+	const speedText = theme
+		? `${theme.fg(speed === null ? "dim" : "accent", speed === null ? "--" : speed.toFixed(1))} ${theme.fg("dim", config.label)}`
+		: `${speed === null ? "--" : speed.toFixed(1)} ${config.label}`;
+	return theme ? `${theme.fg("muted", left)}  ${speedText}` : `${left}  ${speedText}`;
+}
+
+export function crewIndicatorFrames(theme: CrewTheme | undefined): string[] {
+	const frames = crewFrames();
+	if (!theme) return [...frames];
+	return frames.map((frame) => theme.fg("accent", frame));
+}
+
+function formatCapacityPrefix(config: CapacityConfig, usage: CapacityUsage): string {
+	const display: TokenDisplay = config.tokenDisplay;
+	if (display === "off") return "";
+	if (display === "percentage") {
+		return `${usage.percent === null ? "?" : Math.round(Math.max(0, Math.min(999, usage.percent)))}% `;
+	}
+	return `${usage.tokens === null ? "?" : formatCount(usage.tokens)} `;
+}
+
+function colorStage(theme: CrewTheme | undefined, index: number, levels: number, text: string): string {
+	if (!theme || text.length === 0) return text;
+	return theme.fg(isDangerStage(index, levels) ? "error" : "success", text);
+}
+
+export function renderCapacity(theme: CrewTheme | undefined, config: CapacityConfig, usage: CapacityUsage): string {
+	const icons = capacityIcons();
+	const levels = icons.length;
+	const index = capacityIndex(usage.percent, levels);
+	const icon = icons[index] ?? icons[0];
+	const label = config.labels[index] ?? config.labels[0];
+	const prefix = theme ? theme.fg("muted", formatCapacityPrefix(config, usage)) : formatCapacityPrefix(config, usage);
+	const coloredIcon = colorStage(theme, index, levels, icon);
+	const afterIcon = config.showLabel ? `  ${colorStage(theme, index, levels, label)}` : " ";
+	return `${prefix}${coloredIcon}${afterIcon}`;
+}
+
+export function setSpeedStatus(ctx: ExtensionContext, config: CrewVibesConfig, text: string | undefined): void {
+	if (!ctx?.hasUI) return;
+	if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
+		ctx.ui.setStatus(SPEED_STATUS_ID, undefined);
+		return;
+	}
+	ctx.ui.setStatus(SPEED_STATUS_ID, text);
+}
+
+export function setCapacityStatus(ctx: ExtensionContext, config: CrewVibesConfig, text: string | undefined): void {
+	if (!ctx?.hasUI) return;
+	if (!config.enabled || !config.capacity.enabled) {
+		ctx.ui.setStatus(CAPACITY_STATUS_ID, undefined);
+		return;
+	}
+	ctx.ui.setStatus(CAPACITY_STATUS_ID, text);
+}
+
+export function clearVibesStatus(ctx: ExtensionContext): void {
+	if (!ctx?.hasUI) return;
+	ctx.ui.setStatus(SPEED_STATUS_ID, undefined);
+	ctx.ui.setStatus(CAPACITY_STATUS_ID, undefined);
+	ctx.ui.setStatus(PROVIDER_STATUS_ID, undefined);
+	if (ctx.ui.setWorkingIndicator) ctx.ui.setWorkingIndicator();
+	if (ctx.ui.setWorkingMessage) ctx.ui.setWorkingMessage();
+}
+
+// Provider rate-limit usage snapshot (mirrors provider-usage.ts interface).
+// Defined locally to avoid a phase dependency on provider-usage.ts.
+export type ProviderUsage = {
+	providerName: string;
+	fiveHourPercent: number;
+	fiveHourResetAt: string | null;
+	weeklyPercent: number;
+	weeklyResetAt: string | null;
+	copilotMonthlyPercent?: number;
+};
+
+/** Format a time-until-reset duration as a compact `2h30m` / `45m` / `3h` string. */
+function formatResetTimer(resetAt: string | null): string | null {
+	if (!resetAt) return null;
+	const diffMs = new Date(resetAt).getTime() - Date.now();
+	if (diffMs < 0) return null;
+	const mins = Math.floor(diffMs / 60000);
+	if (mins < 60) return `${mins}m`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 48) {
+		const remMins = mins % 60;
+		return remMins > 0 ? `${hours}h${remMins}m` : `${hours}h`;
+	}
+	const days = Math.floor(hours / 24);
+	const remHours = hours % 24;
+	return remHours > 0 ? `${days}d${remHours}h` : `${days}d`;
+}
+
+// Render provider rate-limit usage as a compact status string with bars.
+// Returns `undefined` when there is nothing to show (null usage).
+
+/** Render a progress bar using heavy line characters (matches pi-sub-bar style).
+ * `━━━━━━┄┄┄┄` for 60% — filled uses ━ (U+2501), empty uses ┄ (U+2504). */
+function renderBar(percent: number, width = 8): string {
+	const clamped = Math.max(0, Math.min(100, percent));
+	const filled = Math.round((clamped / 100) * width);
+	return `${"\u2501".repeat(filled)}${"\u2504".repeat(width - filled)}`;
+}
+
+export function renderProviderUsage(theme: CrewTheme | undefined, usage: ProviderUsage | null): string | undefined {
+	if (!usage) return undefined;
+
+	const parts: string[] = [];
+
+	// Provider name — muted/bold
+	if (usage.providerName) {
+		const nameText = usage.providerName;
+		parts.push(theme ? theme.fg("muted", nameText) : nameText);
+	}
+
+	// 5h window — error color at 80%+, accent otherwise
+	const fiveHourBar = renderBar(usage.fiveHourPercent);
+	const fiveHourRounded = Math.round(usage.fiveHourPercent);
+	const fiveHourReset = formatResetTimer(usage.fiveHourResetAt);
+	const fiveHourText = `5h ${fiveHourBar} ${fiveHourRounded}%${fiveHourReset ? " " + fiveHourReset : ""}`;
+	const fiveHourColor = usage.fiveHourPercent >= 80 ? "error" : "accent";
+	parts.push(theme ? theme.fg(fiveHourColor, fiveHourText) : fiveHourText);
+
+	// Weekly window — dim
+	const weeklyBar = renderBar(usage.weeklyPercent);
+	const weeklyRounded = Math.round(usage.weeklyPercent);
+	const weeklyReset = formatResetTimer(usage.weeklyResetAt);
+	const weeklyText = `Wk ${weeklyBar} ${weeklyRounded}%${weeklyReset ? " " + weeklyReset : ""}`;
+	parts.push(theme ? theme.fg("dim", weeklyText) : weeklyText);
+
+	// Copilot monthly — dim (optional)
+	if (typeof usage.copilotMonthlyPercent === "number" && Number.isFinite(usage.copilotMonthlyPercent)) {
+		const monthlyRounded = Math.round(usage.copilotMonthlyPercent);
+		const monthlyText = `Mo: ${monthlyRounded}%`;
+		parts.push(theme ? theme.fg("dim", monthlyText) : monthlyText);
+	}
+
+	return parts.join(" ");
+}
+
+export function setProviderStatus(ctx: ExtensionContext, config: CrewVibesConfig, text: string | undefined): void {
+	if (!ctx?.hasUI) return;
+	if (!config.enabled || !config.capacity.providerUsage) {
+		ctx.ui.setStatus(PROVIDER_STATUS_ID, undefined);
+		return;
+	}
+	ctx.ui.setStatus(PROVIDER_STATUS_ID, text);
+}
+
+export { asCrewTheme };