@eiei114/pi-sub-core 1.5.1

package/src/usage/fetch.ts

@@ -0,0 +1,215 @@
+/**
+ * Usage fetching helpers with cache integration.
+ */
+
+import type { Dependencies, ProviderName, ProviderStatus, UsageSnapshot } from "../types.js";
+import type { Settings } from "../settings-types.js";
+import type { ProviderUsageEntry } from "./types.js";
+import { createProvider } from "../providers/registry.js";
+import { fetchWithCache, getCachedData, readCache, updateCacheStatus, type Cache } from "../cache.js";
+import { fetchProviderStatusWithFallback, providerHasStatus } from "../providers/status.js";
+import { hasProviderCredentials } from "../providers/registry.js";
+import { isExpectedMissingData } from "../errors.js";
+
+export function getCacheTtlMs(settings: Settings): number {
+	return settings.behavior.refreshInterval * 1000;
+}
+
+export function getMinRefreshIntervalMs(settings: Settings): number {
+	return settings.behavior.minRefreshInterval * 1000;
+}
+
+export function getStatusCacheTtlMs(settings: Settings): number {
+	return settings.statusRefresh.refreshInterval * 1000;
+}
+
+export function getStatusMinRefreshIntervalMs(settings: Settings): number {
+	return settings.statusRefresh.minRefreshInterval * 1000;
+}
+
+const PROVIDER_FETCH_CONCURRENCY = 3;
+
+async function mapWithConcurrency<T, R>(
+	items: T[],
+	limit: number,
+	mapper: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+	if (items.length === 0) return [];
+	const results = new Array<R>(items.length);
+	let nextIndex = 0;
+	const workerCount = Math.min(limit, items.length);
+	const workers = Array.from({ length: workerCount }, async () => {
+		while (true) {
+			const currentIndex = nextIndex++;
+			if (currentIndex >= items.length) {
+				return;
+			}
+			results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+
+function resolveStatusFetchedAt(entry?: { fetchedAt: number; statusFetchedAt?: number } | null): number | undefined {
+	if (!entry) return undefined;
+	return entry.statusFetchedAt ?? entry.fetchedAt;
+}
+
+function isWithinMinInterval(fetchedAt: number | undefined, minIntervalMs: number): boolean {
+	if (!fetchedAt || minIntervalMs <= 0) return false;
+	return Date.now() - fetchedAt < minIntervalMs;
+}
+
+function shouldRefreshStatus(
+	settings: Settings,
+	entry?: { fetchedAt: number; statusFetchedAt?: number } | null,
+	options?: { force?: boolean }
+): boolean {
+	const fetchedAt = resolveStatusFetchedAt(entry);
+	const minIntervalMs = getStatusMinRefreshIntervalMs(settings);
+	if (isWithinMinInterval(fetchedAt, minIntervalMs)) return false;
+	if (options?.force) return true;
+	const ttlMs = getStatusCacheTtlMs(settings);
+	if (ttlMs <= 0) return true;
+	if (!fetchedAt) return true;
+	return Date.now() - fetchedAt >= ttlMs;
+}
+
+export async function refreshStatusForProvider(
+	deps: Dependencies,
+	settings: Settings,
+	provider: ProviderName,
+	options?: { force?: boolean }
+): Promise<ProviderStatus | undefined> {
+	const enabledSetting = settings.providers[provider].enabled;
+	if (enabledSetting === "off" || enabledSetting === false) {
+		return undefined;
+	}
+	if (enabledSetting === "auto" && !hasProviderCredentials(provider, deps)) {
+		return undefined;
+	}
+	if (!settings.providers[provider].fetchStatus) {
+		return undefined;
+	}
+
+	const cache = readCache();
+	const entry = cache[provider];
+	const providerInstance = createProvider(provider);
+	const shouldFetch = providerHasStatus(provider, providerInstance) && shouldRefreshStatus(settings, entry, options);
+	if (!shouldFetch) {
+		return entry?.status;
+	}
+	const status = await fetchProviderStatusWithFallback(provider, providerInstance, deps);
+	await updateCacheStatus(provider, status, { statusFetchedAt: Date.now() });
+	return status;
+}
+
+export async function fetchUsageForProvider(
+	deps: Dependencies,
+	settings: Settings,
+	provider: ProviderName,
+	options?: { force?: boolean; forceStatus?: boolean }
+): Promise<{ usage?: UsageSnapshot; status?: ProviderStatus }> {
+	const enabledSetting = settings.providers[provider].enabled;
+	if (enabledSetting === "off" || enabledSetting === false) {
+		return {};
+	}
+	if (enabledSetting === "auto" && !hasProviderCredentials(provider, deps)) {
+		return {};
+	}
+
+	const ttlMs = getCacheTtlMs(settings);
+	const cache = readCache();
+	const cachedEntry = cache[provider];
+	const cachedStatus = cachedEntry?.status;
+	const minIntervalMs = getMinRefreshIntervalMs(settings);
+	if (cachedEntry?.usage && isWithinMinInterval(cachedEntry.fetchedAt, minIntervalMs)) {
+		const usage = { ...cachedEntry.usage, status: cachedEntry.status } as UsageSnapshot;
+		return { usage, status: cachedEntry.status };
+	}
+	const providerInstance = createProvider(provider);
+	const shouldFetchStatus = Boolean(options?.forceStatus)
+		&& settings.providers[provider].fetchStatus
+		&& providerHasStatus(provider, providerInstance);
+
+	if (!options?.force) {
+		const cachedUsage = await getCachedData(provider, ttlMs, cache);
+		if (cachedUsage) {
+			let status = cachedUsage.status;
+			if (shouldFetchStatus) {
+				status = await refreshStatusForProvider(deps, settings, provider, { force: options?.forceStatus ?? options?.force });
+			}
+			const usage = cachedUsage.usage ? { ...cachedUsage.usage, status } : undefined;
+			return { usage, status };
+		}
+	}
+
+	return fetchWithCache(
+		provider,
+		ttlMs,
+		async () => {
+			const usage = await providerInstance.fetchUsage(deps);
+			let status = cachedStatus;
+			let statusFetchedAt = resolveStatusFetchedAt(cachedEntry);
+			if (shouldFetchStatus) {
+				status = await fetchProviderStatusWithFallback(provider, providerInstance, deps);
+				statusFetchedAt = Date.now();
+			} else if (!status) {
+				status = { indicator: "none" as const };
+			}
+
+			return { usage, status, statusFetchedAt };
+		},
+		options,
+	);
+}
+
+export async function getCachedUsageEntry(
+	provider: ProviderName,
+	settings: Settings,
+	cacheSnapshot?: Cache
+): Promise<ProviderUsageEntry | undefined> {
+	const ttlMs = getCacheTtlMs(settings);
+	const cachedEntry = await getCachedData(provider, ttlMs, cacheSnapshot);
+	const usage = cachedEntry?.usage ? { ...cachedEntry.usage, status: cachedEntry.status } : undefined;
+	if (!usage || (usage.error && isExpectedMissingData(usage.error))) {
+		return undefined;
+	}
+	return { provider, usage };
+}
+
+export async function getCachedUsageEntries(
+	providers: ProviderName[],
+	settings: Settings
+): Promise<ProviderUsageEntry[]> {
+	const cache = readCache();
+	const entries: ProviderUsageEntry[] = [];
+	for (const provider of providers) {
+		const entry = await getCachedUsageEntry(provider, settings, cache);
+		if (entry) {
+			entries.push(entry);
+		}
+	}
+	return entries;
+}
+
+export async function fetchUsageEntries(
+	deps: Dependencies,
+	settings: Settings,
+	providers: ProviderName[],
+	options?: { force?: boolean }
+): Promise<ProviderUsageEntry[]> {
+	const concurrency = Math.max(1, Math.min(PROVIDER_FETCH_CONCURRENCY, providers.length));
+	const results = await mapWithConcurrency(providers, concurrency, async (provider) => {
+		const result = await fetchUsageForProvider(deps, settings, provider, options);
+		const usage = result.usage
+			? ({ ...result.usage, status: result.status } as UsageSnapshot)
+			: undefined;
+		if (!usage || (usage.error && isExpectedMissingData(usage.error))) {
+			return undefined;
+		}
+		return { provider, usage } as ProviderUsageEntry;
+	});
+	return results.filter(Boolean) as ProviderUsageEntry[];
+}

package/src/usage/types.ts

@@ -0,0 +1,5 @@
+/**
+ * Usage data types shared across modules.
+ */
+
+export type { ProviderUsageEntry } from "@eiei114/pi-sub-shared";

package/src/utils.ts

@@ -0,0 +1,158 @@
+/**
+ * Utility functions for the sub-bar extension
+ */
+
+import type { Dependencies, RateWindow } from "./types.js";
+import { MODEL_MULTIPLIERS } from "./config.js";
+
+// Only allow simple CLI names (no spaces/paths) to avoid unsafe command execution.
+const SAFE_CLI_NAME = /^[a-zA-Z0-9._-]+$/;
+
+/**
+ * Format a reset date as a relative time string
+ */
+export function formatReset(date: Date): string {
+	const diffMs = date.getTime() - Date.now();
+	if (diffMs < 0) return "now";
+
+	const diffMins = Math.floor(diffMs / 60000);
+	if (diffMins < 60) return `${diffMins}m`;
+
+	const hours = Math.floor(diffMins / 60);
+	const mins = diffMins % 60;
+	if (hours < 24) return mins > 0 ? `${hours}h${mins}m` : `${hours}h`;
+
+	const days = Math.floor(hours / 24);
+	const remHours = hours % 24;
+	return remHours > 0 ? `${days}d${remHours}h` : `${days}d`;
+}
+
+/**
+ * Format elapsed time since a timestamp (milliseconds)
+ */
+export function formatElapsedSince(timestamp: number): string {
+	const diffMs = Date.now() - timestamp;
+	if (diffMs < 60000) return "just now";
+
+	const diffMins = Math.floor(diffMs / 60000);
+	if (diffMins < 60) return `${diffMins}m`;
+
+	const hours = Math.floor(diffMins / 60);
+	const mins = diffMins % 60;
+	if (hours < 24) return mins > 0 ? `${hours}h${mins}m` : `${hours}h`;
+
+	const days = Math.floor(hours / 24);
+	const remHours = hours % 24;
+	return remHours > 0 ? `${days}d${remHours}h` : `${days}d`;
+}
+
+/**
+ * Strip ANSI escape codes from a string
+ */
+export function stripAnsi(text: string): string {
+	return text.replace(/\x1B\[[0-9;?]*[A-Za-z]|\x1B\].*?\x07/g, "");
+}
+
+/**
+ * Normalize a string into tokens for fuzzy matching
+ */
+export function normalizeTokens(value: string): string[] {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, " ")
+		.trim()
+		.split(" ")
+		.filter(Boolean);
+}
+
+/**
+ * Reorder usage windows so those matching the active model come first.
+ * A window matches when every model-ID token appears in the window label
+ * AND the model tokens form a strict majority of the label tokens.
+ * The majority check prevents a short model name (e.g. "gpt-5.3") from
+ * falsely matching a longer, more specific label (e.g. "GPT-5.3-Codex-Spark 5h").
+ * Non-matching windows keep their original relative order.
+ */
+export function prioritizeWindowsForModel(
+	windows: RateWindow[],
+	model?: { id?: string } | null,
+): RateWindow[] {
+	if (!model?.id || windows.length <= 1) return windows;
+
+	const modelTokens = normalizeTokens(model.id);
+	if (modelTokens.length === 0) return windows;
+
+	const matched: RateWindow[] = [];
+	const rest: RateWindow[] = [];
+
+	for (const window of windows) {
+		const labelTokens = normalizeTokens(window.label);
+		const isMatch = modelTokens.every((token) => labelTokens.includes(token))
+			&& modelTokens.length * 2 > labelTokens.length;
+		if (isMatch) {
+			matched.push(window);
+		} else {
+			rest.push(window);
+		}
+	}
+
+	if (matched.length === 0 || matched.length === windows.length) return windows;
+
+	return [...matched, ...rest];
+}
+
+// Pre-computed token entries for model multiplier matching
+const MODEL_MULTIPLIER_TOKENS = Object.entries(MODEL_MULTIPLIERS).map(([label, multiplier]) => ({
+	label,
+	multiplier,
+	tokens: normalizeTokens(label),
+}));
+
+/**
+ * Get the request multiplier for a model ID
+ * Uses fuzzy matching against known model names
+ */
+export function getModelMultiplier(modelId: string | undefined): number | undefined {
+	if (!modelId) return undefined;
+	const modelTokens = normalizeTokens(modelId);
+	if (modelTokens.length === 0) return undefined;
+
+	let bestMatch: { multiplier: number; tokenCount: number } | undefined;
+	for (const entry of MODEL_MULTIPLIER_TOKENS) {
+		const isMatch = entry.tokens.every((token) => modelTokens.includes(token));
+		if (!isMatch) continue;
+		const tokenCount = entry.tokens.length;
+		if (!bestMatch || tokenCount > bestMatch.tokenCount) {
+			bestMatch = { multiplier: entry.multiplier, tokenCount };
+		}
+	}
+
+	return bestMatch?.multiplier;
+}
+
+/**
+ * Check if a command exists in PATH
+ */
+export function whichSync(cmd: string, deps: Dependencies): string | null {
+	if (!SAFE_CLI_NAME.test(cmd)) {
+		return null;
+	}
+
+	try {
+		return deps.execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Create an abort controller with a timeout
+ */
+export function createTimeoutController(timeoutMs: number): { controller: AbortController; clear: () => void } {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+	return {
+		controller,
+		clear: () => clearTimeout(timeoutId),
+	};
+}

package/test/all.test.ts

@@ -0,0 +1,9 @@
+import "./detection.test.js";
+import "./providers.test.js";
+import "./prioritize.test.js";
+import "./controller.test.js";
+import "./extension.test.js";
+import "./cache.test.js";
+import "./lock.test.js";
+import "./status.test.js";
+import "./keybindings.test.js";

package/test/cache.test.ts

@@ -0,0 +1,157 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import * as path from "node:path";
+import {
+	CACHE_PATH,
+	fetchWithCache,
+	onCacheSnapshot,
+	onCacheUpdate,
+	readCache,
+	updateCacheStatus,
+	watchCacheUpdates,
+} from "../src/cache.js";
+import { getCacheLockPath } from "../src/paths.js";
+
+const LOCK_PATH = getCacheLockPath();
+
+function wait(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function withCacheFiles(fn: () => Promise<void> | void): Promise<void> {
+	const cacheDir = path.dirname(CACHE_PATH);
+	const lockDir = path.dirname(LOCK_PATH);
+	fs.mkdirSync(cacheDir, { recursive: true });
+	fs.mkdirSync(lockDir, { recursive: true });
+
+	const cacheExists = fs.existsSync(CACHE_PATH);
+	const lockExists = fs.existsSync(LOCK_PATH);
+	const cacheBackup = cacheExists ? fs.readFileSync(CACHE_PATH, "utf-8") : null;
+	const lockBackup = lockExists ? fs.readFileSync(LOCK_PATH, "utf-8") : null;
+
+	try {
+		await fn();
+	} finally {
+		if (lockBackup !== null) {
+			fs.writeFileSync(LOCK_PATH, lockBackup, "utf-8");
+		} else if (fs.existsSync(LOCK_PATH)) {
+			fs.unlinkSync(LOCK_PATH);
+		}
+		if (cacheBackup !== null) {
+			fs.writeFileSync(CACHE_PATH, cacheBackup, "utf-8");
+		} else if (fs.existsSync(CACHE_PATH)) {
+			fs.unlinkSync(CACHE_PATH);
+		}
+	}
+}
+
+test("readCache recovers from truncated JSON", async () => {
+	await withCacheFiles(() => {
+		const cacheValue = {
+			copilot: {
+				fetchedAt: 123,
+				usage: {
+					provider: "copilot",
+					displayName: "Copilot Plan",
+					windows: [],
+				},
+			},
+		};
+		const corrupted = `${JSON.stringify(cacheValue)}garbage`;
+		fs.writeFileSync(CACHE_PATH, corrupted, "utf-8");
+
+		const cache = readCache();
+		assert.equal(cache.copilot?.fetchedAt, 123);
+
+		const repaired = JSON.parse(fs.readFileSync(CACHE_PATH, "utf-8")) as typeof cacheValue;
+		assert.ok(repaired.copilot);
+	});
+});
+
+test("watchCacheUpdates waits for lock release", async () => {
+	await withCacheFiles(async () => {
+		fs.writeFileSync(CACHE_PATH, "{}", "utf-8");
+		fs.writeFileSync(LOCK_PATH, String(Date.now()), "utf-8");
+
+		const snapshots: Array<Record<string, unknown>> = [];
+		const updates: Array<string> = [];
+		const offSnapshot = onCacheSnapshot((cache) => snapshots.push(cache));
+		const offUpdate = onCacheUpdate((provider) => updates.push(provider));
+		const stop = watchCacheUpdates({ debounceMs: 5, pollIntervalMs: 20, lockRetryMs: 50 });
+
+		const cacheValue = {
+			copilot: {
+				fetchedAt: Date.now(),
+				usage: { provider: "copilot", displayName: "Copilot", windows: [] },
+			},
+		};
+		fs.writeFileSync(CACHE_PATH, JSON.stringify(cacheValue), "utf-8");
+
+		await wait(40);
+		assert.equal(snapshots.length, 0);
+
+		fs.unlinkSync(LOCK_PATH);
+		await wait(80);
+
+		stop();
+		offSnapshot();
+		offUpdate();
+
+		assert.ok(snapshots.length > 0);
+		assert.ok(updates.includes("copilot"));
+	});
+});
+
+test("fetchWithCache skips duplicate fetch when lock is unavailable", async () => {
+	await withCacheFiles(async () => {
+		if (fs.existsSync(CACHE_PATH)) {
+			fs.unlinkSync(CACHE_PATH);
+		}
+		fs.writeFileSync(LOCK_PATH, JSON.stringify({ token: "other", acquiredAt: Date.now() }), "utf-8");
+		const releaseTimer = setTimeout(() => {
+			if (fs.existsSync(LOCK_PATH)) {
+				fs.unlinkSync(LOCK_PATH);
+			}
+		}, 50);
+
+		let fetchCalls = 0;
+		const result = await fetchWithCache("copilot", 0, async () => {
+			fetchCalls += 1;
+			return {
+				usage: {
+					provider: "copilot" as const,
+					displayName: "Copilot",
+					windows: [],
+				},
+			};
+		});
+		clearTimeout(releaseTimer);
+
+		assert.equal(fetchCalls, 0);
+		assert.equal(result.usage, undefined);
+	});
+});
+
+test("updateCacheStatus skips writes when lock is unavailable", async () => {
+	await withCacheFiles(async () => {
+		const initialCache = {
+			copilot: {
+				fetchedAt: 123,
+				usage: {
+					provider: "copilot",
+					displayName: "Copilot",
+					windows: [],
+				},
+				status: { indicator: "none" as const },
+			},
+		};
+		fs.writeFileSync(CACHE_PATH, JSON.stringify(initialCache), "utf-8");
+		fs.writeFileSync(LOCK_PATH, JSON.stringify({ token: "other", acquiredAt: Date.now() }), "utf-8");
+
+		await updateCacheStatus("copilot", { indicator: "major" });
+
+		const after = JSON.parse(fs.readFileSync(CACHE_PATH, "utf-8")) as typeof initialCache;
+		assert.equal(after.copilot.status?.indicator, "none");
+	});
+});

package/test/controller.test.ts

@@ -0,0 +1,101 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createUsageController } from "../src/usage/controller.js";
+import { getDefaultSettings } from "../src/settings-types.js";
+import { CACHE_PATH } from "../src/cache.js";
+import { getStorage, setStorage, type StorageAdapter } from "../src/storage.js";
+import { createDeps, createJsonResponse, getAuthPath } from "./helpers.js";
+import type { UsageSnapshot } from "../src/types.js";
+
+function createMemoryStorage(): { storage: StorageAdapter; files: Map<string, string> } {
+	const files = new Map<string, string>();
+	const storage: StorageAdapter = {
+		readFile: (filePath) => files.get(filePath),
+		writeFile: (filePath, contents) => {
+			files.set(filePath, contents);
+		},
+		writeFileExclusive: (filePath, contents) => {
+			if (files.has(filePath)) return false;
+			files.set(filePath, contents);
+			return true;
+		},
+		exists: (filePath) => files.has(filePath),
+		removeFile: (filePath) => {
+			files.delete(filePath);
+		},
+		ensureDir: () => {},
+	};
+	return { storage, files };
+}
+
+test("refresh clears state when provider is not detected", async () => {
+	const { deps } = createDeps({
+		fetch: async () => createJsonResponse({}),
+	});
+	const controller = createUsageController(deps);
+	const settings = getDefaultSettings();
+	const state = {
+		currentProvider: "copilot" as const,
+		cachedUsage: { provider: "copilot", displayName: "Copilot", windows: [] },
+		lastSuccessAt: Date.now(),
+		providerCycleIndex: 0,
+	};
+	const updates: Array<{ provider?: string }> = [];
+
+	await controller.refresh({ model: undefined } as never, settings, state, (update) => updates.push(update));
+
+	assert.equal(state.currentProvider, undefined);
+	assert.equal(state.cachedUsage, undefined);
+	assert.equal(updates.at(-1)?.provider, undefined);
+});
+
+test("refresh falls back to cached usage on fetch error", async () => {
+	const { storage, files } = createMemoryStorage();
+	const originalStorage = getStorage();
+	setStorage(storage);
+
+	try {
+		const home = "/home/test";
+		const { deps, files: depFiles } = createDeps({
+			fetch: async () => createJsonResponse({}, { ok: false, status: 500 }),
+			homedir: home,
+		});
+		depFiles.set(getAuthPath(home), JSON.stringify({ "github-copilot": { refresh: "token" } }));
+
+		const cachedUsage: UsageSnapshot = {
+			provider: "copilot",
+			displayName: "Copilot Plan",
+			windows: [{ label: "Month", usedPercent: 10 }],
+		};
+		const cacheEntry = {
+			fetchedAt: Date.now() - 5000,
+			usage: cachedUsage,
+			status: { indicator: "none" as const },
+		};
+		files.set(CACHE_PATH, JSON.stringify({ copilot: cacheEntry }));
+
+		const controller = createUsageController(deps);
+		const settings = getDefaultSettings();
+		settings.behavior.minRefreshInterval = 0;
+		settings.providers.copilot.enabled = "on";
+
+		const state = { providerCycleIndex: 0 };
+		const updates: Array<{ usage?: UsageSnapshot }> = [];
+
+		await controller.refresh(
+			{ model: { provider: "github" } } as never,
+			settings,
+			state,
+			(update) => updates.push(update),
+			{ force: true },
+		);
+
+		const finalUsage = updates.at(-1)?.usage;
+		assert.ok(finalUsage);
+		assert.equal(finalUsage?.windows.length, 1);
+		assert.equal(finalUsage?.status?.indicator, "minor");
+		assert.equal(finalUsage?.error?.code, "HTTP_ERROR");
+	} finally {
+		setStorage(originalStorage);
+	}
+});

package/test/detection.test.ts

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { detectProviderFromModel } from "../src/providers/detection.js";
+
+
+test("detectProviderFromModel prefers provider tokens over model tokens", () => {
+	const provider = detectProviderFromModel({ provider: "OpenAI", id: "claude-3-opus" });
+	assert.equal(provider, "codex");
+});
+
+test("detectProviderFromModel is case-insensitive", () => {
+	const provider = detectProviderFromModel({ provider: "GITHUB", id: "copilot" });
+	assert.equal(provider, "copilot");
+});
+
+test("detectProviderFromModel falls back to model tokens", () => {
+	const provider = detectProviderFromModel({ id: "claude-3.5-sonnet" });
+	assert.equal(provider, "anthropic");
+});
+
+test("detectProviderFromModel handles overlapping provider tokens", () => {
+	const provider = detectProviderFromModel({ provider: "z.ai", id: "model" });
+	assert.equal(provider, "zai");
+});