@eiei114/pi-sub-core 1.5.1

package/src/status.ts

@@ -0,0 +1,245 @@
+/**
+ * Status polling for providers
+ */
+
+import type { Dependencies, ProviderName, ProviderStatus, StatusIndicator } from "./types.js";
+import type { ProviderStatusConfig } from "./providers/metadata.js";
+import { GOOGLE_STATUS_URL, GEMINI_PRODUCT_ID, API_TIMEOUT_MS } from "./config.js";
+import { PROVIDER_METADATA } from "./providers/metadata.js";
+import { createTimeoutController } from "./utils.js";
+
+type StatusPageStatusConfig = Extract<ProviderStatusConfig, { type: "statuspage" }>;
+
+interface StatusPageSummary {
+	status?: {
+		indicator?: string;
+		description?: string;
+	};
+	components?: Array<{
+		id?: string;
+		name?: string;
+		status?: string;
+	}>;
+}
+
+interface StatusPageStatus {
+	indicator?: string;
+	description?: string;
+}
+
+interface StatusPageResponse {
+	status?: StatusPageStatus;
+}
+
+function toSummaryUrl(url: string): string {
+	if (url.endsWith("/summary.json")) return url;
+	if (url.endsWith("/status.json")) {
+		return `${url.slice(0, -"/status.json".length)}/summary.json`;
+	}
+	if (!url.endsWith("/")) return `${url}/summary.json`;
+	return `${url}summary.json`;
+}
+
+function isComponentMatch(component: { id?: string; name?: string }, config?: StatusPageStatusConfig): boolean {
+	if (!config?.component) return false;
+
+	if (config.component.id && component.id) {
+		return component.id === config.component.id;
+	}
+
+	if (config.component.name && component.name) {
+		return component.name.trim().toLowerCase() === config.component.name.trim().toLowerCase();
+	}
+
+	return false;
+}
+
+function mapStatusIndicator(indicator?: string): StatusIndicator {
+	switch (indicator) {
+		case "none":
+			return "none";
+		case "minor":
+			return "minor";
+		case "major":
+			return "major";
+		case "critical":
+			return "critical";
+		case "maintenance":
+			return "maintenance";
+		default:
+			return "unknown";
+	}
+}
+
+function mapComponentStatus(indicator?: string): StatusIndicator {
+	switch ((indicator || "").toLowerCase()) {
+		case "operational":
+			return "none";
+		case "under_maintenance":
+			return "maintenance";
+		case "degraded_performance":
+			return "minor";
+		case "partial_outage":
+			return "major";
+		case "major_outage":
+			return "critical";
+		default:
+			return "unknown";
+	}
+}
+
+function formatComponentLabel(rawStatus?: string): string {
+	switch ((rawStatus || "").toLowerCase()) {
+		case "operational":
+			return "Operational";
+		case "under_maintenance":
+			return "Under maintenance";
+		case "degraded_performance":
+			return "Degraded performance";
+		case "partial_outage":
+			return "Partial outage";
+		case "major_outage":
+			return "Major outage";
+		default:
+			return rawStatus ? rawStatus.replace(/_/g, " ") : "Unknown";
+	}
+}
+
+/**
+ * Fetch status from a standard statuspage.io API
+ */
+async function fetchStatuspageStatus(
+	url: string,
+	deps: Dependencies,
+	config?: StatusPageStatusConfig
+): Promise<ProviderStatus> {
+	const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+	try {
+		const fetchUrl = config?.component ? toSummaryUrl(url) : url;
+		const res = await deps.fetch(fetchUrl, { signal: controller.signal });
+		clear();
+
+		if (!res.ok) {
+			return { indicator: "unknown" };
+		}
+
+		if (!config?.component) {
+			const data = (await res.json()) as StatusPageResponse;
+			const indicator = mapStatusIndicator(data.status?.indicator);
+			return { indicator, description: data.status?.description };
+		}
+
+		const data = (await res.json()) as StatusPageSummary;
+		const summaryIndicator = mapStatusIndicator(data.status?.indicator);
+		const component = (data.components ?? []).find((entry) => isComponentMatch(entry, config));
+		if (component) {
+			const componentIndicator = mapComponentStatus(component.status);
+			const componentDescription =
+				componentIndicator === "none"
+					? undefined
+					: `${component.name ?? "Component"}: ${formatComponentLabel(component.status)}`;
+			return {
+				indicator: componentIndicator,
+				description: componentDescription,
+			};
+		}
+
+		return {
+			indicator: summaryIndicator,
+			description: data.status?.description,
+		};
+	} catch {
+		clear();
+		return { indicator: "unknown" };
+	}
+}
+
+/**
+ * Fetch Gemini status from Google Workspace status API
+ */
+async function fetchGeminiStatus(deps: Dependencies): Promise<ProviderStatus> {
+	const { controller, clear } = createTimeoutController(API_TIMEOUT_MS);
+
+	try {
+		const res = await deps.fetch(GOOGLE_STATUS_URL, { signal: controller.signal });
+		clear();
+
+		if (!res.ok) return { indicator: "unknown" };
+
+		const incidents = (await res.json()) as Array<{
+			end?: string;
+			currently_affected_products?: Array<{ id: string }>;
+			affected_products?: Array<{ id: string }>;
+			most_recent_update?: { status?: string };
+			status_impact?: string;
+			external_desc?: string;
+		}>;
+
+		const activeIncidents = incidents.filter((inc) => {
+			if (inc.end) return false;
+			const affected = inc.currently_affected_products || inc.affected_products || [];
+			return affected.some((p) => p.id === GEMINI_PRODUCT_ID);
+		});
+
+		if (activeIncidents.length === 0) {
+			return { indicator: "none" };
+		}
+
+		let worstIndicator: StatusIndicator = "minor";
+		let description: string | undefined;
+
+		for (const inc of activeIncidents) {
+			const status = inc.most_recent_update?.status || inc.status_impact;
+			if (status === "SERVICE_OUTAGE") {
+				worstIndicator = "critical";
+				description = inc.external_desc;
+			} else if (status === "SERVICE_DISRUPTION" && worstIndicator !== "critical") {
+				worstIndicator = "major";
+				description = inc.external_desc;
+			}
+		}
+
+		return { indicator: worstIndicator, description };
+	} catch {
+		clear();
+		return { indicator: "unknown" };
+	}
+}
+
+/**
+ * Fetch status for a provider
+ */
+export async function fetchProviderStatus(provider: ProviderName, deps: Dependencies): Promise<ProviderStatus> {
+	const statusConfig = PROVIDER_METADATA[provider]?.status;
+	if (!statusConfig) {
+		return { indicator: "none" };
+	}
+
+	if (statusConfig.type === "google-workspace") {
+		return fetchGeminiStatus(deps);
+	}
+
+	return fetchStatuspageStatus(statusConfig.url, deps, statusConfig);
+}
+
+/**
+ * Get emoji for a status indicator
+ */
+export function getStatusEmoji(status?: ProviderStatus): string {
+	if (!status) return "";
+	switch (status.indicator) {
+		case "none":
+			return "✅";
+		case "minor":
+			return "⚠️";
+		case "major":
+			return "🟠";
+		case "critical":
+			return "🔴";
+		case "maintenance":
+			return "🔧";
+		default:
+			return "";
+	}
+}

package/src/storage/lock.ts

@@ -0,0 +1,150 @@
+/**
+ * File lock helpers for storage-backed locks.
+ */
+
+import { getStorage } from "../storage.js";
+
+interface LockRecord {
+	acquiredAt: number;
+	token?: string;
+}
+
+export function tryAcquireFileLock(lockPath: string, staleAfterMs: number): string | null {
+	const storage = getStorage();
+	const token = createLockToken();
+	if (tryCreateLock(storage, lockPath, token)) {
+		return token;
+	}
+
+	const observed = readLockRecord(storage, lockPath);
+	if (!observed) {
+		return null;
+	}
+	if (!isLockStale(observed.acquiredAt, staleAfterMs)) {
+		return null;
+	}
+	if (!removeObservedStaleLock(storage, lockPath, observed)) {
+		return null;
+	}
+	if (tryCreateLock(storage, lockPath, token)) {
+		return token;
+	}
+
+	return null;
+}
+
+export function releaseFileLock(lockPath: string, token?: string): void {
+	const storage = getStorage();
+	try {
+		if (!storage.exists(lockPath)) {
+			return;
+		}
+		if (token) {
+			const current = readLockRecord(storage, lockPath);
+			if (!current?.token || current.token !== token) {
+				return;
+			}
+		}
+		storage.removeFile(lockPath);
+	} catch {
+		// Ignore
+	}
+}
+
+export async function waitForLockRelease(
+	lockPath: string,
+	maxWaitMs: number,
+	pollMs: number = 100
+): Promise<boolean> {
+	const storage = getStorage();
+	const startTime = Date.now();
+
+	while (Date.now() - startTime < maxWaitMs) {
+		await new Promise((resolve) => setTimeout(resolve, pollMs));
+		if (!storage.exists(lockPath)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function tryCreateLock(storage: ReturnType<typeof getStorage>, lockPath: string, token: string): boolean {
+	try {
+		return storage.writeFileExclusive(lockPath, serializeLockRecord({ token, acquiredAt: Date.now() }));
+	} catch {
+		return false;
+	}
+}
+
+function removeObservedStaleLock(
+	storage: ReturnType<typeof getStorage>,
+	lockPath: string,
+	observed: LockRecord
+): boolean {
+	try {
+		const current = readLockRecord(storage, lockPath);
+		if (!current) {
+			return false;
+		}
+		if (current.acquiredAt !== observed.acquiredAt) {
+			return false;
+		}
+		if (current.token !== observed.token) {
+			return false;
+		}
+		storage.removeFile(lockPath);
+		return !storage.exists(lockPath);
+	} catch {
+		return false;
+	}
+}
+
+function readLockRecord(storage: ReturnType<typeof getStorage>, lockPath: string): LockRecord | null {
+	try {
+		if (!storage.exists(lockPath)) {
+			return null;
+		}
+		const lockContent = storage.readFile(lockPath) ?? "";
+		return parseLockRecord(lockContent);
+	} catch {
+		return null;
+	}
+}
+
+function parseLockRecord(lockContent: string): LockRecord | null {
+	const trimmed = lockContent.trim();
+	if (!trimmed) return null;
+
+	const asTimestamp = parseInt(trimmed, 10);
+	if (Number.isFinite(asTimestamp) && asTimestamp > 0) {
+		return { acquiredAt: asTimestamp };
+	}
+
+	try {
+		const parsed = JSON.parse(trimmed) as { token?: unknown; acquiredAt?: unknown; createdAt?: unknown };
+		const acquiredAt = parsed.acquiredAt ?? parsed.createdAt;
+		if (typeof acquiredAt !== "number" || !Number.isFinite(acquiredAt) || acquiredAt <= 0) {
+			return null;
+		}
+		const token = typeof parsed.token === "string" && parsed.token ? parsed.token : undefined;
+		return { acquiredAt, token };
+	} catch {
+		return null;
+	}
+}
+
+function serializeLockRecord(record: LockRecord): string {
+	return JSON.stringify(record);
+}
+
+function isLockStale(acquiredAt: number, staleAfterMs: number): boolean {
+	if (staleAfterMs <= 0) {
+		return true;
+	}
+	return Date.now() - acquiredAt > staleAfterMs;
+}
+
+function createLockToken(): string {
+	return `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}

package/src/storage.ts

@@ -0,0 +1,61 @@
+/**
+ * Storage abstraction for settings and cache persistence.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface StorageAdapter {
+	readFile(path: string): string | undefined;
+	writeFile(path: string, contents: string): void;
+	writeFileExclusive(path: string, contents: string): boolean;
+	exists(path: string): boolean;
+	removeFile(path: string): void;
+	ensureDir(path: string): void;
+}
+
+export function createFsStorage(): StorageAdapter {
+	return {
+		readFile(filePath: string): string | undefined {
+			try {
+				return fs.readFileSync(filePath, "utf-8");
+			} catch {
+				return undefined;
+			}
+		},
+		writeFile(filePath: string, contents: string): void {
+			fs.writeFileSync(filePath, contents, "utf-8");
+		},
+		writeFileExclusive(filePath: string, contents: string): boolean {
+			try {
+				fs.writeFileSync(filePath, contents, { flag: "wx" });
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		exists(filePath: string): boolean {
+			return fs.existsSync(filePath);
+		},
+		removeFile(filePath: string): void {
+			try {
+				fs.unlinkSync(filePath);
+			} catch {
+				// Ignore remove errors
+			}
+		},
+		ensureDir(dirPath: string): void {
+			fs.mkdirSync(path.resolve(dirPath), { recursive: true });
+		},
+	};
+}
+
+let activeStorage: StorageAdapter = createFsStorage();
+
+export function getStorage(): StorageAdapter {
+	return activeStorage;
+}
+
+export function setStorage(storage: StorageAdapter): void {
+	activeStorage = storage;
+}

package/src/types.ts

@@ -0,0 +1,33 @@
+/**
+ * Core types for the sub-bar extension
+ */
+
+import type { ExecFileSyncOptionsWithStringEncoding } from "node:child_process";
+
+export type {
+	ProviderName,
+	StatusIndicator,
+	ProviderStatus,
+	RateWindow,
+	UsageSnapshot,
+	UsageError,
+	UsageErrorCode,
+	ProviderUsageEntry,
+	SubCoreState,
+	SubCoreEvents,
+} from "@eiei114/pi-sub-shared";
+
+export { PROVIDERS } from "@eiei114/pi-sub-shared";
+
+/**
+ * Dependencies that can be injected for testing
+ */
+export interface Dependencies {
+	fetch: typeof globalThis.fetch;
+	readFile: (path: string) => string | undefined;
+	fileExists: (path: string) => boolean;
+	// Use static commands/args only (no user-controlled input).
+	execFileSync: (file: string, args: string[], options?: ExecFileSyncOptionsWithStringEncoding) => string;
+	homedir: () => string;
+	env: NodeJS.ProcessEnv;
+}

package/src/ui/keybindings.ts

@@ -0,0 +1,92 @@
+import * as PiTui from "@mariozechner/pi-tui";
+
+export type SettingsListAction =
+	| "selectUp"
+	| "selectDown"
+	| "cursorLeft"
+	| "cursorRight"
+	| "selectConfirm"
+	| "selectCancel";
+
+export interface SettingsKeybindings {
+	matches(data: string, action: SettingsListAction): boolean;
+}
+
+interface CompatibleApi {
+	getEditorKeybindings?: () => { matches(data: string, action: string): boolean };
+	getKeybindings?: () => { matches(data: string, action: string): boolean };
+	matchesKey?: (data: string, key: string) => boolean;
+}
+
+const LEGACY_ACTION_MAP: Record<SettingsListAction, string> = {
+	selectUp: "tui.select.up",
+	selectDown: "tui.select.down",
+	cursorLeft: "tui.editor.cursorLeft",
+	cursorRight: "tui.editor.cursorRight",
+	selectConfirm: "tui.select.confirm",
+	selectCancel: "tui.select.cancel",
+};
+
+const DEFAULT_ACTION_KEYS: Record<SettingsListAction, string | string[]> = {
+	selectUp: "up",
+	selectDown: "down",
+	cursorLeft: ["left", "ctrl+b"],
+	cursorRight: ["right", "ctrl+f"],
+	selectConfirm: "enter",
+	selectCancel: ["escape", "ctrl+c"],
+};
+
+function matchesKeyWithFallback(
+	data: string,
+	key: string,
+	matchesKey?: (data: string, key: string) => boolean,
+): boolean {
+	if (matchesKey) {
+		return matchesKey(data, key);
+	}
+
+	if (key === "enter") return data === "\r" || data === "\n";
+	if (key === "escape") return data === "\u001b";
+	if (key === "up") return data === "\u001b[A";
+	if (key === "down") return data === "\u001b[B";
+	if (key === "left") return data === "\u001b[D";
+	if (key === "right") return data === "\u001b[C";
+	return data === key;
+}
+
+function matchesDefaultAction(
+	data: string,
+	action: SettingsListAction,
+	matchesKey?: (data: string, key: string) => boolean,
+): boolean {
+	const keys = DEFAULT_ACTION_KEYS[action];
+	const list = Array.isArray(keys) ? keys : [keys];
+	return list.some((key) => matchesKeyWithFallback(data, key, matchesKey));
+}
+
+export function createSettingsKeybindings(api: CompatibleApi): SettingsKeybindings {
+	const editor = api.getEditorKeybindings?.();
+	if (editor && typeof editor.matches === "function") {
+		return {
+			matches: (data, action) => editor.matches(data, action),
+		};
+	}
+
+	const legacy = api.getKeybindings?.();
+	if (legacy && typeof legacy.matches === "function") {
+		return {
+			matches: (data, action) => {
+				const legacyAction = LEGACY_ACTION_MAP[action];
+				return legacy.matches(data, legacyAction);
+			},
+		};
+	}
+
+	return {
+		matches: (data, action) => matchesDefaultAction(data, action, api.matchesKey),
+	};
+}
+
+export function getSettingsKeybindings(): SettingsKeybindings {
+	return createSettingsKeybindings(PiTui as CompatibleApi);
+}