@eiei114/pi-sub-core 1.5.1

package/test/extension.test.ts

@@ -0,0 +1,233 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import type { ExtensionAPI, ExtensionContext } from '@mariozechner/pi-coding-agent';
+import createExtension from '../index.js';
+import { CACHE_PATH, clearCache } from '../src/cache.js';
+import { SETTINGS_PATH } from '../src/settings.js';
+import { getStorage, setStorage, type StorageAdapter } from '../src/storage.js';
+import { createDeps, getAuthPath } from './helpers.js';
+
+interface PiHarness {
+	pi: ExtensionAPI;
+	emitLifecycle: (event: string, ctx: ExtensionContext) => Promise<void>;
+}
+
+/**
+ * Build a minimal ExtensionAPI mock that captures lifecycle handlers
+ * (`pi.on(event, handler)`) and exposes them via `emitLifecycle` for
+ * deterministic invocation in tests.
+ */
+function createPiHarness(): PiHarness {
+	const lifecycle = new Map<string, Array<(event: unknown, ctx: ExtensionContext) => unknown>>();
+	const eventListeners = new Map<string, Array<(payload: unknown) => unknown>>();
+
+	const events = {
+		on(event: string, handler: (payload: unknown) => unknown) {
+			const list = eventListeners.get(event) ?? [];
+			list.push(handler);
+			eventListeners.set(event, list);
+		},
+		emit(event: string, payload?: unknown) {
+			for (const handler of eventListeners.get(event) ?? []) {
+				handler(payload);
+			}
+		},
+	};
+
+	const pi = {
+		events,
+		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown) {
+			const list = lifecycle.get(event) ?? [];
+			list.push(handler);
+			lifecycle.set(event, list);
+		},
+		registerCommand: () => {},
+		registerTool: () => {},
+		registerShortcut: () => {},
+		registerFlag: () => {},
+		getFlag: () => undefined,
+		registerMessageRenderer: () => {},
+		sendMessage: () => {},
+		sendUserMessage: () => {},
+		appendEntry: () => {},
+		setSessionName: () => {},
+		getSessionName: () => undefined,
+		setLabel: () => {},
+		exec: async () => ({ code: 0, stdout: '', stderr: '' }),
+		getActiveTools: () => [],
+		getAllTools: () => [],
+		setActiveTools: () => {},
+		setModel: async () => true,
+		getThinkingLevel: () => 'high',
+		setThinkingLevel: () => {},
+		registerProvider: () => {},
+	} as unknown as ExtensionAPI;
+
+	return {
+		pi,
+		async emitLifecycle(event, ctx) {
+			for (const handler of lifecycle.get(event) ?? []) {
+				await handler({ type: event }, ctx);
+			}
+		},
+	};
+}
+
+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 };
+}
+
+function createCtx(): ExtensionContext {
+	return {
+		ui: {
+			select: async () => undefined,
+			confirm: async () => false,
+			input: async () => undefined,
+			notify: () => {},
+			setStatus: () => {},
+			setWorkingMessage: () => {},
+			setWidget: () => {},
+			setFooter: () => {},
+			setHeader: () => {},
+			setTitle: () => {},
+			custom: async () => undefined,
+			setEditorText: () => {},
+		},
+		hasUI: false,
+		cwd: '/tmp/project',
+		sessionManager: {} as ExtensionContext['sessionManager'],
+		modelRegistry: {} as ExtensionContext['modelRegistry'],
+		model: { provider: 'anthropic', id: 'claude-opus-4-7' } as ExtensionContext['model'],
+		isIdle: () => true,
+		abort: () => {},
+		hasPendingMessages: () => false,
+		shutdown: () => {},
+		getContextUsage: () => undefined,
+		compact: () => {},
+		getSystemPrompt: () => '',
+	} as ExtensionContext;
+}
+
+function resetGlobal(): void {
+	const g = globalThis as typeof globalThis & { __piSubCore?: { active: boolean } };
+	g.__piSubCore = undefined;
+}
+
+/**
+ * Regression for marckrenn/pi-sub#58.
+ *
+ * Before the fix, `turn_end` and `tool_result` (with `refreshOnToolResult` enabled)
+ * called `refresh(ctx, { force: true })`. That bypassed the cache TTL and triggered
+ * an upstream fetch on every turn, hammering rate-limited endpoints (e.g. anthropic
+ * OAuth `/usage`) and, when the endpoint started returning 429, leaving the cache
+ * stuck because `fetchWithCache` refuses to write entries with errors.
+ *
+ * With the fix, both handlers call `refresh(ctx)` without `force`, so the existing
+ * `behavior.refreshInterval` (60s) and `behavior.minRefreshInterval` (10s) gates
+ * correctly suppress redundant network calls when the cache is fresh.
+ */
+test('turn_end and tool_result do not bypass the cache TTL when the entry is fresh', async () => {
+	const originalStorage = getStorage();
+	const { storage, files } = createMemoryStorage();
+	setStorage(storage);
+	clearCache();
+	resetGlobal();
+
+	try {
+		const home = '/home/test';
+		let fetchCount = 0;
+		const { deps, files: depFiles } = createDeps({
+			fetch: async () => {
+				fetchCount += 1;
+				return {
+					ok: true,
+					status: 200,
+					json: async () => ({}),
+				} as Response;
+			},
+			homedir: home,
+		});
+		// anthropic provider reads ~/.pi/agent/auth.json under `anthropic.access`.
+		depFiles.set(getAuthPath(home), JSON.stringify({ anthropic: { access: 'token' } }));
+
+		// Pre-populate the cache: 30s old. That's past the 10s minRefreshInterval but
+		// well within the 60s ttl. Without `force`, fetchUsageForProvider must return
+		// the cached value; with `force: true` (the bug) it bypasses the ttl and fetches.
+		const fetchedAt = Date.now() - 30_000;
+		files.set(
+			CACHE_PATH,
+			JSON.stringify({
+				anthropic: {
+					fetchedAt,
+					statusFetchedAt: fetchedAt,
+					usage: {
+						provider: 'anthropic',
+						displayName: 'Anthropic (Claude)',
+						windows: [
+							{ label: '5h', usedPercent: 12, resetDescription: '4h' },
+							{ label: 'Week', usedPercent: 25, resetDescription: '3d' },
+						],
+					},
+					status: { indicator: 'none' },
+				},
+			}),
+		);
+
+		// Enable refresh on tool result so the tool_result handler actually calls refresh.
+		files.set(
+			SETTINGS_PATH,
+			JSON.stringify({
+				version: 3,
+				behavior: { refreshOnToolResult: true, refreshInterval: 60, minRefreshInterval: 10 },
+				statusRefresh: { refreshOnToolResult: true, refreshInterval: 60, minRefreshInterval: 10 },
+				providers: { anthropic: { enabled: 'on', fetchStatus: false } },
+			}),
+		);
+
+		const harness = createPiHarness();
+		createExtension(harness.pi, deps);
+
+		const ctx = createCtx();
+		await harness.emitLifecycle('session_start', ctx);
+		// session_start emits with skipFetch:true, so it should not hit the network.
+		assert.equal(fetchCount, 0, 'session_start should never fetch');
+
+		await harness.emitLifecycle('turn_end', ctx);
+		assert.equal(
+			fetchCount,
+			0,
+			'turn_end must respect cache TTL and not refetch when the entry is fresh',
+		);
+
+		await harness.emitLifecycle('tool_result', ctx);
+		assert.equal(
+			fetchCount,
+			0,
+			'tool_result must respect cache TTL and not refetch when the entry is fresh',
+		);
+
+		// Cleanup so the global guard, intervals and watchers do not leak across tests.
+		await harness.emitLifecycle('session_shutdown', ctx);
+	} finally {
+		resetGlobal();
+		setStorage(originalStorage);
+		clearCache();
+	}
+});

package/test/helpers.ts

@@ -0,0 +1,48 @@
+import path from "node:path";
+import type { Dependencies } from "../src/types.js";
+
+export type FetchResponse<T> = {
+	ok: boolean;
+	status: number;
+	json: () => Promise<T>;
+};
+
+export function createJsonResponse<T>(data: T, init?: { ok?: boolean; status?: number }): FetchResponse<T> {
+	return {
+		ok: init?.ok ?? true,
+		status: init?.status ?? 200,
+		json: async () => data,
+	};
+}
+
+export function createDeps(options?: {
+	files?: Record<string, string>;
+	fetch?: Dependencies["fetch"];
+	execFileSync?: Dependencies["execFileSync"];
+	env?: NodeJS.ProcessEnv;
+	homedir?: string;
+}): { deps: Dependencies; files: Map<string, string> } {
+	const files = new Map<string, string>(Object.entries(options?.files ?? {}));
+	const homedir = options?.homedir ?? "/home/test";
+
+	const deps: Dependencies = {
+		fetch: options?.fetch
+			?? (async () => {
+				throw new Error("fetch not mocked");
+			}),
+		readFile: (filePath: string) => files.get(filePath),
+		fileExists: (filePath: string) => files.has(filePath),
+		execFileSync: options?.execFileSync
+			?? (() => {
+				throw new Error("execFileSync not mocked");
+			}),
+		homedir: () => homedir,
+		env: options?.env ?? {},
+	};
+
+	return { deps, files };
+}
+
+export function getAuthPath(home: string): string {
+	return path.join(home, ".pi", "agent", "auth.json");
+}

package/test/keybindings.test.ts

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createSettingsKeybindings } from "../src/ui/keybindings.js";
+
+test("settings keybindings prefer editor keybindings when available", () => {
+	const kb = createSettingsKeybindings({
+		getEditorKeybindings: () => ({
+			matches: (data, action) => data === "X" && action === "selectDown",
+		}),
+		getKeybindings: () => ({
+			matches: () => {
+				throw new Error("legacy keybindings should not be used when editor keybindings exist");
+			},
+		}),
+	});
+
+	assert.equal(kb.matches("X", "selectDown"), true);
+	assert.equal(kb.matches("X", "selectUp"), false);
+});
+
+test("settings keybindings map actions to legacy keybinding IDs", () => {
+	const seen: string[] = [];
+	const kb = createSettingsKeybindings({
+		getKeybindings: () => ({
+			matches: (_data, action) => {
+				seen.push(action);
+				return action === "tui.select.down";
+			},
+		}),
+	});
+
+	assert.equal(kb.matches("ignored", "selectDown"), true);
+	assert.equal(kb.matches("ignored", "cursorLeft"), false);
+	assert.deepEqual(seen, ["tui.select.down", "tui.editor.cursorLeft"]);
+});
+
+test("settings keybindings fallback uses matchesKey helper when no keybinding manager exists", () => {
+	const kb = createSettingsKeybindings({
+		matchesKey: (data, key) => data === `<<${key}>>`,
+	});
+
+	assert.equal(kb.matches("<<up>>", "selectUp"), true);
+	assert.equal(kb.matches("<<down>>", "selectDown"), true);
+	assert.equal(kb.matches("<<left>>", "cursorLeft"), true);
+	assert.equal(kb.matches("<<enter>>", "selectConfirm"), true);
+	assert.equal(kb.matches("<<escape>>", "selectCancel"), true);
+	assert.equal(kb.matches("<<right>>", "cursorLeft"), false);
+});
+
+test("settings keybindings fallback handles raw escape sequences", () => {
+	const kb = createSettingsKeybindings({});
+
+	assert.equal(kb.matches("\u001b[A", "selectUp"), true);
+	assert.equal(kb.matches("\u001b[B", "selectDown"), true);
+	assert.equal(kb.matches("\u001b[D", "cursorLeft"), true);
+	assert.equal(kb.matches("\u001b[C", "cursorRight"), true);
+	assert.equal(kb.matches("\r", "selectConfirm"), true);
+	assert.equal(kb.matches("\u001b", "selectCancel"), true);
+});

package/test/lock.test.ts

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getStorage, setStorage, type StorageAdapter } from "../src/storage.js";
+import { tryAcquireFileLock, releaseFileLock } from "../src/storage/lock.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("tryAcquireFileLock replaces stale locks with owned tokens", () => {
+	const { storage, files } = createMemoryStorage();
+	const originalStorage = getStorage();
+	setStorage(storage);
+
+	try {
+		const lockPath = "/tmp/lock";
+		const firstToken = tryAcquireFileLock(lockPath, 10);
+		assert.ok(firstToken);
+		files.set(lockPath, String(Date.now() - 1000));
+		const secondToken = tryAcquireFileLock(lockPath, 10);
+		assert.ok(secondToken);
+		assert.notEqual(secondToken, firstToken);
+
+		releaseFileLock(lockPath, firstToken ?? undefined);
+		assert.equal(files.has(lockPath), true);
+
+		releaseFileLock(lockPath, secondToken ?? undefined);
+		assert.equal(files.has(lockPath), false);
+	} finally {
+		setStorage(originalStorage);
+	}
+});

package/test/prioritize.test.ts

@@ -0,0 +1,81 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { RateWindow } from "../src/types.js";
+import { prioritizeWindowsForModel } from "../src/utils.js";
+
+function window(label: string, usedPercent = 0): RateWindow {
+	return { label, usedPercent };
+}
+
+test("codex spark windows are moved before general windows", () => {
+	const windows = [
+		window("5h", 0),
+		window("Week", 1),
+		window("GPT-5.3-Codex-Spark 5h", 2),
+		window("GPT-5.3-Codex-Spark Week", 3),
+	];
+
+	const result = prioritizeWindowsForModel(windows, { id: "gpt-5.3-codex-spark" });
+
+	assert.deepEqual(
+		result.map((w) => w.label),
+		["GPT-5.3-Codex-Spark 5h", "GPT-5.3-Codex-Spark Week", "5h", "Week"],
+	);
+});
+
+test("antigravity current model window is moved first", () => {
+	const windows = [
+		window("Gemini 2.5 Pro"),
+		window("Gemini 3 Flash"),
+		window("Gemini 3 Pro"),
+		window("Gemini 3.5 Flash"),
+	];
+
+	const result = prioritizeWindowsForModel(windows, { id: "gemini-3-pro" });
+
+	assert.deepEqual(
+		result.map((w) => w.label),
+		["Gemini 3 Pro", "Gemini 2.5 Pro", "Gemini 3 Flash", "Gemini 3.5 Flash"],
+	);
+});
+
+test("returns original array when no windows match the model", () => {
+	const windows = [window("5h"), window("Week")];
+
+	const result = prioritizeWindowsForModel(windows, { id: "claude-3.5-sonnet" });
+
+	assert.equal(result, windows);
+});
+
+test("returns original array when all windows match", () => {
+	const windows = [
+		window("GPT-5.3-Codex-Spark 5h"),
+		window("GPT-5.3-Codex-Spark Week"),
+	];
+
+	const result = prioritizeWindowsForModel(windows, { id: "gpt-5.3-codex-spark" });
+
+	assert.equal(result, windows);
+});
+
+test("non-spark codex model does not match spark windows", () => {
+	const windows = [
+		window("5h", 0),
+		window("Week", 1),
+		window("GPT-5.3-Codex-Spark 5h", 2),
+		window("GPT-5.3-Codex-Spark Week", 3),
+	];
+
+	const result = prioritizeWindowsForModel(windows, { id: "gpt-5.3" });
+
+	assert.equal(result, windows);
+});
+
+test("returns original array when model is absent", () => {
+	const windows = [window("5h"), window("Week")];
+
+	assert.equal(prioritizeWindowsForModel(windows, undefined), windows);
+	assert.equal(prioritizeWindowsForModel(windows, null), windows);
+	assert.equal(prioritizeWindowsForModel(windows, { id: undefined }), windows);
+	assert.equal(prioritizeWindowsForModel(windows, { id: "" }), windows);
+});