@eiei114/pi-sub-bar 1.5.1

package/src/settings.ts

@@ -0,0 +1,176 @@
+/**
+ * Settings persistence for sub-bar
+ */
+
+import * as path from "node:path";
+import type { Settings } from "./settings-types.js";
+import { getDefaultSettings, mergeSettings } from "./settings-types.js";
+import { getStorage } from "./storage.js";
+import { getLegacySettingsPath, getSettingsPath } from "./paths.js";
+
+/**
+ * Settings file path
+ */
+export const SETTINGS_PATH = getSettingsPath();
+const LEGACY_SETTINGS_PATH = getLegacySettingsPath();
+
+/**
+ * In-memory settings cache
+ */
+let cachedSettings: Settings | undefined;
+
+/**
+ * Ensure the settings directory exists
+ */
+function ensureSettingsDir(): void {
+	const storage = getStorage();
+	const dir = path.dirname(SETTINGS_PATH);
+	storage.ensureDir(dir);
+}
+
+/**
+ * Parse settings file contents
+ */
+function parseSettings(content: string): Settings {
+	const loaded = JSON.parse(content) as Partial<Settings>;
+	return mergeSettings({
+		version: loaded.version,
+		display: loaded.display,
+		providers: loaded.providers,
+		displayThemes: loaded.displayThemes,
+		displayUserTheme: loaded.displayUserTheme,
+		pinnedProvider: loaded.pinnedProvider,
+		keybindings: loaded.keybindings,
+	} as Partial<Settings>);
+}
+
+function loadSettingsFromDisk(settingsPath: string): Settings | null {
+	const storage = getStorage();
+	if (storage.exists(settingsPath)) {
+		const content = storage.readFile(settingsPath);
+		if (content) {
+			return parseSettings(content);
+		}
+	}
+	return null;
+}
+
+function tryLoadSettings(settingsPath: string): Settings | null {
+	try {
+		return loadSettingsFromDisk(settingsPath);
+	} catch (error) {
+		console.error(`Failed to load settings from ${settingsPath}:`, error);
+		return null;
+	}
+}
+
+/**
+ * Load settings from disk
+ */
+export function loadSettings(): Settings {
+	if (cachedSettings) {
+		return cachedSettings;
+	}
+
+	const diskSettings = tryLoadSettings(SETTINGS_PATH);
+	if (diskSettings) {
+		cachedSettings = diskSettings;
+		return cachedSettings;
+	}
+
+	const legacySettings = tryLoadSettings(LEGACY_SETTINGS_PATH);
+	if (legacySettings) {
+		const saved = saveSettings(legacySettings);
+		if (saved) {
+			getStorage().removeFile(LEGACY_SETTINGS_PATH);
+		}
+		cachedSettings = legacySettings;
+		return cachedSettings;
+	}
+
+	// Return defaults if file doesn't exist or failed to load
+	cachedSettings = getDefaultSettings();
+	return cachedSettings;
+}
+
+/**
+ * Save settings to disk
+ */
+export function saveSettings(settings: Settings): boolean {
+	const storage = getStorage();
+	try {
+		ensureSettingsDir();
+		let next = settings;
+		if (cachedSettings) {
+			const diskSettings = loadSettingsFromDisk(SETTINGS_PATH);
+			if (diskSettings) {
+				const displayChanged = JSON.stringify(settings.display) !== JSON.stringify(cachedSettings.display);
+				const providersChanged = JSON.stringify(settings.providers) !== JSON.stringify(cachedSettings.providers);
+				const themesChanged = JSON.stringify(settings.displayThemes) !== JSON.stringify(cachedSettings.displayThemes);
+				const userThemeChanged = JSON.stringify(settings.displayUserTheme) !== JSON.stringify(cachedSettings.displayUserTheme);
+				const pinnedChanged = settings.pinnedProvider !== cachedSettings.pinnedProvider;
+				const keybindingsChanged = JSON.stringify(settings.keybindings) !== JSON.stringify(cachedSettings.keybindings);
+
+				next = {
+					...diskSettings,
+					version: settings.version,
+					display: displayChanged ? settings.display : diskSettings.display,
+					providers: providersChanged ? settings.providers : diskSettings.providers,
+					displayThemes: themesChanged ? settings.displayThemes : diskSettings.displayThemes,
+					displayUserTheme: userThemeChanged ? settings.displayUserTheme : diskSettings.displayUserTheme,
+					pinnedProvider: pinnedChanged ? settings.pinnedProvider : diskSettings.pinnedProvider,
+					keybindings: keybindingsChanged ? settings.keybindings : diskSettings.keybindings,
+				};
+			}
+		}
+		const content = JSON.stringify({
+			version: next.version,
+			display: next.display,
+			providers: next.providers,
+			displayThemes: next.displayThemes,
+			displayUserTheme: next.displayUserTheme,
+			pinnedProvider: next.pinnedProvider,
+			keybindings: next.keybindings,
+		}, null, 2);
+		storage.writeFile(SETTINGS_PATH, content);
+		cachedSettings = next;
+		return true;
+	} catch (error) {
+		console.error(`Failed to save settings to ${SETTINGS_PATH}:`, error);
+		return false;
+	}
+}
+
+/**
+ * Reset settings to defaults
+ */
+export function resetSettings(): Settings {
+	const defaults = getDefaultSettings();
+	const current = getSettings();
+	const next = {
+		...current,
+		display: defaults.display,
+		providers: defaults.providers,
+		displayThemes: defaults.displayThemes,
+		displayUserTheme: defaults.displayUserTheme,
+		pinnedProvider: defaults.pinnedProvider,
+		keybindings: defaults.keybindings,
+		version: defaults.version,
+	};
+	saveSettings(next);
+	return next;
+}
+
+/**
+ * Get current settings (cached)
+ */
+export function getSettings(): Settings {
+	return loadSettings();
+}
+
+/**
+ * Clear the settings cache (force reload on next access)
+ */
+export function clearSettingsCache(): void {
+	cachedSettings = undefined;
+}

package/src/share.ts

@@ -0,0 +1,75 @@
+/**
+ * Display theme share helpers.
+ */
+
+import type { Settings } from "./settings-types.js";
+import { mergeSettings } from "./settings-types.js";
+
+const SHARE_SEPARATOR = ":";
+const DISPLAY_SHARE_VERSION = 1;
+
+export interface DisplaySharePayload {
+	v: number;
+	display: Settings["display"];
+}
+
+export interface DecodedDisplayShare {
+	name: string;
+	display: Settings["display"];
+	version: number;
+	isNewerVersion: boolean;
+	hasName: boolean;
+}
+
+function encodeDisplaySharePayload(display: Settings["display"]): string {
+	const payload: DisplaySharePayload = { v: DISPLAY_SHARE_VERSION, display };
+	return Buffer.from(JSON.stringify(payload)).toString("base64url");
+}
+
+export function buildDisplayShareString(name: string, display: Settings["display"]): string {
+	const encoded = encodeDisplaySharePayload(display);
+	const trimmedName = name.trim() || "custom";
+	return `${trimmedName}${SHARE_SEPARATOR}${encoded}`;
+}
+
+export function buildDisplayShareStringWithoutName(display: Settings["display"]): string {
+	return encodeDisplaySharePayload(display);
+}
+
+export function decodeDisplayShareString(input: string): DecodedDisplayShare | null {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	let name = "custom";
+	let hasName = false;
+	let payload = trimmed;
+	const separatorIndex = trimmed.indexOf(SHARE_SEPARATOR);
+	if (separatorIndex >= 0) {
+		const candidateName = trimmed.slice(0, separatorIndex).trim();
+		payload = trimmed.slice(separatorIndex + 1).trim();
+		if (candidateName) {
+			name = candidateName;
+			hasName = true;
+		}
+	}
+	if (!payload) return null;
+	try {
+		const decoded = Buffer.from(payload, "base64url").toString("utf-8");
+		const parsed = JSON.parse(decoded) as unknown;
+		if (!parsed || typeof parsed !== "object") return null;
+		const displayCandidate = (parsed as DisplaySharePayload).display ?? parsed;
+		if (!displayCandidate || typeof displayCandidate !== "object" || Array.isArray(displayCandidate)) {
+			return null;
+		}
+		const merged = mergeSettings({ display: displayCandidate } as Partial<Settings>).display;
+		const version = typeof (parsed as DisplaySharePayload).v === "number" ? (parsed as DisplaySharePayload).v : 0;
+		return {
+			name,
+			display: merged,
+			version,
+			isNewerVersion: version > DISPLAY_SHARE_VERSION,
+			hasName,
+		};
+	} catch {
+		return null;
+	}
+}

package/src/status.ts

@@ -0,0 +1,103 @@
+/**
+ * Status indicator helpers.
+ */
+
+import type { ProviderStatus } from "./types.js";
+import type { StatusIconPack } from "./settings-types.js";
+
+const STATUS_ICON_PACKS: Record<Exclude<StatusIconPack, "custom">, Record<ProviderStatus["indicator"], string>> = {
+	minimal: {
+		none: "✓",
+		minor: "⚠",
+		major: "⚠",
+		critical: "×",
+		maintenance: "~",
+		unknown: "?",
+	},
+	emoji: {
+		none: "✅",
+		minor: "⚠️",
+		major: "🟠",
+		critical: "🔴",
+		maintenance: "🔧",
+		unknown: "❓",
+	},
+};
+
+const DEFAULT_CUSTOM_ICONS = ["✓", "⚠", "×", "?"];
+const CUSTOM_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+function parseCustomIcons(value?: string): [string, string, string, string] {
+	if (!value) return DEFAULT_CUSTOM_ICONS as [string, string, string, string];
+	const segments = Array.from(CUSTOM_SEGMENTER.segment(value), (entry) => entry.segment)
+		.map((segment) => segment.trim())
+		.filter(Boolean);
+	if (segments.length < 3) return DEFAULT_CUSTOM_ICONS as [string, string, string, string];
+	if (segments.length === 3) {
+		return [segments[0], segments[1], segments[2], DEFAULT_CUSTOM_ICONS[3]] as [string, string, string, string];
+	}
+	return [segments[0], segments[1], segments[2], segments[3]] as [string, string, string, string];
+}
+
+function buildCustomPack(custom?: string): Record<ProviderStatus["indicator"], string> {
+	const [ok, warn, error, unknown] = parseCustomIcons(custom);
+	return {
+		none: ok,
+		minor: warn,
+		major: error,
+		critical: error,
+		maintenance: warn,
+		unknown,
+	};
+}
+
+export function getStatusIcon(
+	status: ProviderStatus | undefined,
+	pack: StatusIconPack,
+	custom?: string,
+): string {
+	if (!status) return "";
+	if (pack === "custom") {
+		return buildCustomPack(custom)[status.indicator] ?? "";
+	}
+	return STATUS_ICON_PACKS[pack][status.indicator] ?? "";
+}
+
+export function getStatusLabel(
+	status: ProviderStatus | undefined,
+	useAbbreviated = false,
+): string {
+	if (!status) return "";
+	if (useAbbreviated) {
+		switch (status.indicator) {
+			case "none":
+				return "Status OK";
+			case "minor":
+				return "Status Degr.";
+			case "major":
+			case "critical":
+				return "Status Crit.";
+			case "maintenance":
+				return "Status Maint.";
+			case "unknown":
+			default:
+				return "Status Unk.";
+		}
+	}
+	if (status.description) return status.description;
+	switch (status.indicator) {
+		case "none":
+			return "Operational";
+		case "minor":
+			return "Degraded";
+		case "major":
+			return "Outage";
+		case "critical":
+			return "Outage";
+		case "maintenance":
+			return "Maintenance";
+		case "unknown":
+		default:
+			return "Status Unknown";
+	}
+}

package/src/storage.ts

@@ -0,0 +1,61 @@
+/**
+ * Storage abstraction for settings 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,25 @@
+/**
+ * Core types for the sub-bar extension
+ */
+
+export type {
+	ProviderName,
+	StatusIndicator,
+	ProviderStatus,
+	RateWindow,
+	UsageSnapshot,
+	UsageError,
+	UsageErrorCode,
+	ProviderUsageEntry,
+	SubCoreState,
+	SubCoreAllState,
+	SubCoreEvents,
+} from "@eiei114/pi-sub-shared";
+
+export { PROVIDERS } from "@eiei114/pi-sub-shared";
+
+export type ModelInfo = {
+	provider?: string;
+	id?: string;
+	scopedModelPatterns?: string[];
+};

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);
+}