osdy-pi 1.2.0 → 1.3.0

package/extensions/osdy-pi/runtime.ts

@@ -12,17 +12,22 @@ import { createEditorSettingsStore } from "./editor-settings.js";
 import { registerAccountProfilesCommand } from "./account-profiles.js";
 import {
 	applyOsdyPi,
+	clearGentleShellChangesWidget,
 	createResponsiveCoordinator,
 	disableOsdyPi,
 	notifyStatus,
 	reconcileResponsiveUi,
+	syncWorkingTreeWidget,
 } from "./runtime-helpers.js";
 import { runSoundSetupWizard } from "./sound-setup-wizard.js";
 import {
 	DEFAULT_EDITOR_MODE,
 	EDITOR_MODES,
+	HEADER_VARIANT_CHOICES,
 	type EditorMode,
 	type HeaderVariant,
+	MASCOT_CHOICES,
+	type MascotChoice,
 	type OsdyState,
 	type WorkingTreeState,
 	type WorkingWidgetState,
@@ -34,6 +39,15 @@ import {
 	shouldRefreshWorkingTree,
 } from "./working-tree.js";
 import { showWorkingTreeDiffPanel } from "./diff-panel.js";
+import {
+	extractCodexAccountId,
+	fetchCodexUsage,
+	type CodexUsageAuth,
+	type CodexUsageSnapshot,
+} from "./codex-usage.js";
+import { showCodexUsagePanel } from "./codex-usage-ui.js";
+import { modelLabel } from "./metrics.js";
+import { resolveActiveProfileLabel } from "./profile-label.js";
 import {
 	createWorkingController,
 	type WorkingController,
@@ -86,10 +100,35 @@ function parseCommandArgs(args: string): string[] {
 	return args.trim().split(/\s+/).filter(Boolean);
 }
 
-const HEADER_VARIANTS = ["osdy-theme", "classic"] as const;
+function isMascotChoice(value: string): value is MascotChoice {
+	return MASCOT_CHOICES.includes(value as MascotChoice);
+}
+
+function mascotLabel(mascot: MascotChoice): string {
+	return mascot === "bts" ? "Bts" : mascot;
+}
 
 function isHeaderVariant(value: string): value is HeaderVariant {
-	return HEADER_VARIANTS.includes(value as HeaderVariant);
+	return HEADER_VARIANT_CHOICES.includes(value as HeaderVariant);
+}
+
+async function saveVisualSettings(
+	state: OsdyState,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<boolean> {
+	try {
+		await settingsStore.save({
+			version: 1,
+			enabled: state.enabled,
+			editorMode: state.editorMode,
+			workingTreeEnabled: state.workingTreeEnabled,
+			headerVariant: state.headerVariant,
+			mascot: state.mascot,
+		});
+		return true;
+	} catch {
+		return false;
+	}
 }
 
 async function enableOsdyPi(
@@ -99,55 +138,124 @@ async function enableOsdyPi(
 	workingState: WorkingWidgetState,
 	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
 ): Promise<void> {
 	state.enabled = true;
-	applyOsdyPi(pi, ctx, state, workingState, workingTreeState, true);
+	applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
 	controller.refreshWorking();
+	const saved = await saveVisualSettings(state, settingsStore);
 	if (state.workingTreeEnabled)
 		await refreshWorkingTree(pi, ctx, workingTreeState);
+	ctx.ui.notify(
+		saved ? "osdy-pi enabled" : "osdy-pi enabled but could not be saved",
+		saved ? "info" : "warning",
+	);
 }
 
-function disableOsdyPiCommand(
+async function disableOsdyPiCommand(
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
 	stopResponsive: () => void,
-): void {
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<void> {
 	stopResponsive();
 	state.enabled = false;
 	workingTreeState.visible = false;
 	controller.stopWorking();
 	clearWorkingTree(workingTreeState);
 	disableOsdyPi(ctx, state);
+	const saved = await saveVisualSettings(state, settingsStore);
+	ctx.ui.notify(
+		saved ? "osdy-pi disabled" : "osdy-pi disabled but could not be saved",
+		saved ? "info" : "warning",
+	);
 }
 
-function setHeaderVariant(
+async function handleMascotCommand(
+	action: string | undefined,
+	rest: string[],
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	state: OsdyState,
 	workingState: WorkingWidgetState,
 	workingTreeState: WorkingTreeState,
-	variant: HeaderVariant,
-): void {
-	state.headerVariant = variant;
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<void> {
+	const mascotUsage = `Usage: /osdy-pi mascot ${MASCOT_CHOICES.join(" | ")} | status`;
+	if (rest.length > 0) {
+		ctx.ui.notify(mascotUsage, "warning");
+		return;
+	}
+	if (action === "status" || action === undefined) {
+		ctx.ui.notify(`osdy-pi mascot: ${mascotLabel(state.mascot)}`, "info");
+		return;
+	}
+	if (!isMascotChoice(action)) {
+		ctx.ui.notify(mascotUsage, "warning");
+		return;
+	}
+	state.mascot = action;
+	if (state.enabled) applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
+	const saved = await saveVisualSettings(state, settingsStore);
+	ctx.ui.notify(
+		saved
+			? `osdy-pi mascot: ${mascotLabel(action)}`
+			: "osdy-pi mascot changed but could not be saved",
+		saved ? "info" : "warning",
+	);
+}
+
+async function handleHeaderCommand(
+	action: string | undefined,
+	rest: string[],
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<void> {
+	const headerUsage = `Usage: /osdy-pi header ${HEADER_VARIANT_CHOICES.join(" | ")} | status`;
+	if (
+		rest.length > 0 ||
+		(action !== undefined && action !== "status" && !isHeaderVariant(action))
+	) {
+		ctx.ui.notify(headerUsage, "warning");
+		return;
+	}
+	if (action === "status" || action === undefined) {
+		ctx.ui.notify(`osdy-pi header: ${state.headerVariant}`, "info");
+		return;
+	}
+	state.headerVariant = action;
 	if (state.enabled) applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
-	ctx.ui.notify(`osdy-pi style: ${variant}`, "info");
+	const saved = await saveVisualSettings(state, settingsStore);
+	ctx.ui.notify(
+		saved
+			? `osdy-pi header: ${action}`
+			: "osdy-pi header changed but could not be saved",
+		saved ? "info" : "warning",
+	);
 }
 
-function getOsdyCommandCompletions(prefix: string) {
+export function getOsdyCommandCompletions(prefix: string) {
 	const trimmed = prefix.trim();
 	const parts = parseCommandArgs(trimmed);
 	if (parts.length === 0) {
 		return [
 			"enable",
 			"disable",
+			"on",
+			"off",
 			"status",
 			"sound",
 			"working-tree",
 			"editor",
+			"mascot",
+			"header",
 			"diff",
-			...HEADER_VARIANTS,
 		].map((value) => ({ value, label: value }));
 	}
 	if (trimmed === "sound") {
@@ -163,6 +271,18 @@ function getOsdyCommandCompletions(prefix: string) {
 			"working-tree position bottom",
 		].map((value) => ({ value, label: value }));
 	}
+	if (trimmed === "mascot") {
+		return [
+			...MASCOT_CHOICES.map((choice) => `mascot ${choice}`),
+			"mascot status",
+		].map((value) => ({ value, label: value }));
+	}
+	if (trimmed === "header") {
+		return [
+			...HEADER_VARIANT_CHOICES.map((choice) => `header ${choice}`),
+			"header status",
+		].map((value) => ({ value, label: value }));
+	}
 	if (trimmed === "editor") {
 		return [
 			"editor auto",
@@ -179,12 +299,15 @@ function getOsdyCommandCompletions(prefix: string) {
 		return [
 			"enable",
 			"disable",
+			"on",
+			"off",
 			"status",
 			"sound",
 			"working-tree",
 			"editor",
+			"mascot",
+			"header",
 			"diff",
-			...HEADER_VARIANTS,
 		]
 			.filter((value) => value.startsWith(valuePrefix))
 			.map((value) => ({ value, label: value }));
@@ -195,6 +318,18 @@ function getOsdyCommandCompletions(prefix: string) {
 			.filter((value) => value.startsWith(valuePrefix))
 			.map((value) => ({ value: `sound ${value}`, label: `sound ${value}` }));
 	}
+	if (parts[0] === "header" && parts.length === 2) {
+		const valuePrefix = parts[1] ?? "";
+		return [...HEADER_VARIANT_CHOICES, "status"]
+			.filter((value) => value.startsWith(valuePrefix))
+			.map((value) => ({ value: `header ${value}`, label: `header ${value}` }));
+	}
+	if (parts[0] === "mascot" && parts.length === 2) {
+		const valuePrefix = parts[1] ?? "";
+		return [...MASCOT_CHOICES, "status"]
+			.filter((value) => value.startsWith(valuePrefix))
+			.map((value) => ({ value: `mascot ${value}`, label: `mascot ${value}` }));
+	}
 	if (parts[0] === "editor" && parts.length === 2) {
 		const valuePrefix = parts[1] ?? "";
 		return ["auto", "extended", "simple", "on", "off", "toggle", "status"]
@@ -287,19 +422,13 @@ async function setEditorMode(
 ): Promise<void> {
 	state.editorMode = mode;
 	if (state.enabled) reconcileResponsiveUi(pi, ctx, state, workingTreeState);
-	try {
-		await settingsStore.save({
-			version: 1,
-			editorMode: mode,
-			workingTreeEnabled: state.workingTreeEnabled,
-		});
-		ctx.ui.notify(`osdy-pi editor mode: ${mode}`, "info");
-	} catch {
-		ctx.ui.notify(
-			"osdy-pi editor mode changed but could not be saved",
-			"warning",
-		);
-	}
+	const saved = await saveVisualSettings(state, settingsStore);
+	ctx.ui.notify(
+		saved
+			? `osdy-pi editor mode: ${mode}`
+			: "osdy-pi editor mode changed but could not be saved",
+		saved ? "info" : "warning",
+	);
 }
 
 async function handleEditorCommand(
@@ -360,16 +489,7 @@ async function saveWorkingTreePreference(
 	state: OsdyState,
 	settingsStore: ReturnType<typeof createEditorSettingsStore>,
 ): Promise<boolean> {
-	try {
-		await settingsStore.save({
-			version: 1,
-			editorMode: state.editorMode,
-			workingTreeEnabled: state.workingTreeEnabled,
-		});
-		return true;
-	} catch {
-		return false;
-	}
+	return saveVisualSettings(state, settingsStore);
 }
 
 async function handleWorkingTreeCommand(
@@ -396,6 +516,7 @@ async function handleWorkingTreeCommand(
 	if (action === "on") {
 		state.workingTreeEnabled = true;
 		workingTreeState.enabled = true;
+		syncWorkingTreeWidget(ctx, state, workingState, workingTreeState);
 		reconcileResponsiveUi(pi, ctx, state, workingTreeState);
 		const saved = await saveWorkingTreePreference(state, settingsStore);
 		await refreshWorkingTree(pi, ctx, workingTreeState);
@@ -410,6 +531,7 @@ async function handleWorkingTreeCommand(
 	if (action === "off") {
 		state.workingTreeEnabled = false;
 		workingTreeState.enabled = false;
+		syncWorkingTreeWidget(ctx, state, workingState, workingTreeState);
 		reconcileResponsiveUi(pi, ctx, state, workingTreeState);
 		clearWorkingTree(workingTreeState);
 		const saved = await saveWorkingTreePreference(state, settingsStore);
@@ -481,6 +603,95 @@ async function openDiffCommand(
 	}
 }
 
+type CodexUsageRefreshContext = {
+	modelRegistry: {
+		getProviderAuth(
+			provider: string,
+		): Promise<{ auth: { apiKey?: string } } | undefined>;
+	};
+};
+
+type CodexUsageRefreshState = {
+	codexUsage: OsdyState["codexUsage"];
+	tui?: { requestRender(): void } | undefined;
+};
+
+type CodexUsageFetcher = (
+	auth: CodexUsageAuth,
+	options: { signal: AbortSignal },
+) => Promise<CodexUsageSnapshot>;
+
+export async function refreshCodexUsage(
+	ctx: CodexUsageRefreshContext,
+	state: CodexUsageRefreshState,
+	abort: AbortController,
+	fetchUsage: CodexUsageFetcher = fetchCodexUsage,
+): Promise<void> {
+	state.codexUsage = { kind: "loading", snapshot: undefined };
+	state.tui?.requestRender();
+	try {
+		const providerAuth = await ctx.modelRegistry.getProviderAuth("openai-codex");
+		const accessToken = providerAuth?.auth.apiKey;
+		if (!accessToken) throw new Error("Codex login is required");
+		const snapshot = await fetchUsage(
+			{ accessToken, accountId: extractCodexAccountId(accessToken) },
+			{ signal: abort.signal },
+		);
+		if (abort.signal.aborted) return;
+		state.codexUsage = { kind: "ready", snapshot };
+	} catch (error) {
+		if (abort.signal.aborted) return;
+		state.codexUsage = {
+			kind: "error",
+			message:
+				error instanceof Error ? error.message : "Codex usage is unavailable",
+			snapshot: undefined,
+		};
+	}
+	state.tui?.requestRender();
+}
+
+export function createActiveSessionRefresh<T>(
+	getSessionContext: () => T | undefined,
+	startRefresh: (context: T) => Promise<void>,
+): () => Promise<void> {
+	return async () => {
+		const activeSessionContext = getSessionContext();
+		if (activeSessionContext) await startRefresh(activeSessionContext);
+	};
+}
+
+function registerUsageCommand(
+	pi: ExtensionAPI,
+	state: OsdyState,
+	getSessionContext: () => ExtensionContext | undefined,
+	startRefresh: (ctx: ExtensionContext) => Promise<void>,
+): void {
+	const refreshActiveSessionUsage = createActiveSessionRefresh(
+		getSessionContext,
+		startRefresh,
+	);
+	pi.registerCommand("usage", {
+		description: "Show current Codex subscription usage.",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("Codex usage requires the interactive UI", "warning");
+				return;
+			}
+			await showCodexUsagePanel(
+				ctx,
+				() => state.codexUsage,
+				refreshActiveSessionUsage,
+				{
+					profile: resolveActiveProfileLabel(),
+					provider: ctx.model?.provider ?? "unknown",
+					model: modelLabel(ctx),
+				},
+			);
+		},
+	});
+}
+
 function registerCommand(
 	pi: ExtensionAPI,
 	state: OsdyState,
@@ -494,11 +705,11 @@ function registerCommand(
 ): void {
 	pi.registerCommand("osdy-pi", {
 		description:
-			"Manage the Osdy Pi experience: enable, disable, status, editor, style, sound setup, working tree, or diff panel.",
+			"Manage the Osdy Pi experience: enable/disable (on/off), status, mascot, editor, style, sound setup, working tree, or diff panel.",
 		getArgumentCompletions: getOsdyCommandCompletions,
 		handler: async (args, ctx) => {
 			const [action = "status", ...rest] = parseCommandArgs(args);
-			if (action === "enable") {
+			if (["enable", "on"].includes(action)) {
 				await enableOsdyPi(
 					pi,
 					ctx,
@@ -506,17 +717,19 @@ function registerCommand(
 					workingState,
 					workingTreeState,
 					controller,
+					editorSettingsStore,
 				);
 				startResponsive();
 				return;
 			}
-			if (action === "disable") {
-				disableOsdyPiCommand(
+			if (["disable", "off"].includes(action)) {
+				await disableOsdyPiCommand(
 					ctx,
 					state,
 					workingTreeState,
 					controller,
 					stopResponsive,
+					editorSettingsStore,
 				);
 				return;
 			}
@@ -528,6 +741,32 @@ function registerCommand(
 				await handleSoundCommand(rest, ctx, settingsStore);
 				return;
 			}
+			if (action === "mascot") {
+				await handleMascotCommand(
+					rest[0],
+					rest.slice(1),
+					pi,
+					ctx,
+					state,
+					workingState,
+					workingTreeState,
+					editorSettingsStore,
+				);
+				return;
+			}
+			if (action === "header") {
+				await handleHeaderCommand(
+					rest[0],
+					rest.slice(1),
+					pi,
+					ctx,
+					state,
+					workingState,
+					workingTreeState,
+					editorSettingsStore,
+				);
+				return;
+			}
 			if (action === "editor") {
 				await handleEditorCommand(
 					rest[0],
@@ -557,34 +796,23 @@ function registerCommand(
 				await openDiffCommand(pi, ctx, state, workingState, workingTreeState);
 				return;
 			}
-			if (isHeaderVariant(action)) {
-				setHeaderVariant(pi, ctx, state, workingState, workingTreeState, action);
-				return;
-			}
 			ctx.ui.notify(
-				"Usage: /osdy-pi enable | disable | status | editor auto|extended|simple|on|off|toggle|status | sound setup | working-tree ... | diff | osdy-theme | classic",
+				`Usage: /osdy-pi enable|disable|on|off|status | mascot ${MASCOT_CHOICES.join("|")}|status | header ${HEADER_VARIANT_CHOICES.join("|")}|status | editor auto|extended|simple|on|off|toggle|status | sound setup | working-tree ... | diff`,
 				"warning",
 			);
 		},
 	});
-
-	for (const variant of HEADER_VARIANTS) {
-		pi.registerCommand(`osdy-pi-${variant}`, {
-			description: `Switch Osdy Pi header to ${variant}.`,
-			handler: (_args, ctx) => {
-				setHeaderVariant(pi, ctx, state, workingState, workingTreeState, variant);
-				return Promise.resolve();
-			},
-		});
-	}
 }
 
 export function registerOsdyPi(pi: ExtensionAPI): void {
 	const state: OsdyState = {
+		codexUsage: { kind: "idle" },
 		enabled: true,
 		editorEffective: false,
 		editorMode: DEFAULT_EDITOR_MODE,
+		fallbackEditorFactory: undefined,
 		headerVariant: "osdy-theme",
+		mascot: "current",
 		smallMode: false,
 		tui: undefined,
 		workingTreeEnabled: true,
@@ -609,7 +837,6 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	const settingsStore = createAudioSoundSettingsStore();
 	const editorSettingsStore = createEditorSettingsStore();
 	registerAudioNotificationFlags(pi);
-	registerAccountProfilesCommand(pi);
 	const audioRouter = createAudioEventRouter(
 		createAudioNotificationService(
 			pi,
@@ -621,12 +848,42 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 		| ReturnType<typeof createResponsiveCoordinator>
 		| undefined;
 	let sessionContext: ExtensionContext | undefined;
+	let codexUsageAbort: AbortController | undefined;
+	const refreshCurrentCodexUsage = async (
+		ctx: ExtensionContext,
+	): Promise<void> => {
+		codexUsageAbort?.abort();
+		const abort = new AbortController();
+		codexUsageAbort = abort;
+		await refreshCodexUsage(ctx, state, abort);
+		if (codexUsageAbort === abort) codexUsageAbort = undefined;
+	};
+	registerAccountProfilesCommand(pi, {
+		requestRender: () => {
+			state.tui?.requestRender();
+		},
+		refreshUsage: async () => {
+			const activeSessionContext = sessionContext;
+			if (activeSessionContext)
+				await refreshCurrentCodexUsage(activeSessionContext);
+		},
+	});
 	const pendingOsdyRefreshes = new Set<ReturnType<typeof setTimeout>>();
 	const cancelOsdyRefreshes = (): void => {
 		for (const timeout of pendingOsdyRefreshes) clearTimeout(timeout);
 		pendingOsdyRefreshes.clear();
 	};
-	const startResponsive = (): void => responsiveCoordinator?.start();
+	const startResponsive = (): void => {
+		if (!responsiveCoordinator && sessionContext) {
+			responsiveCoordinator = createResponsiveCoordinator(
+				pi,
+				sessionContext,
+				state,
+				workingTreeState,
+			);
+		}
+		responsiveCoordinator?.start();
+	};
 	const stopResponsive = (): void => responsiveCoordinator?.stop();
 
 	subscribeQuestionPromptAudioNotification(
@@ -642,6 +899,17 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	pi.on("agent_end", (_event, ctx) => {
 		controller.onAgentEnd();
 		audioRouter.onAgentEnd(ctx);
+		if (state.enabled) clearGentleShellChangesWidget(ctx);
+	});
+	pi.on("agent_settled", () => {
+		const activeSessionContext = sessionContext;
+		if (
+			state.enabled &&
+			activeSessionContext &&
+			activeSessionContext.model?.provider === "openai-codex"
+		) {
+			void refreshCurrentCodexUsage(activeSessionContext);
+		}
 	});
 	pi.on("tool_execution_start", (event) =>
 		controller.onToolStart(event.toolName),
@@ -649,7 +917,9 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	pi.on("tool_execution_end", (event, ctx) => {
 		controller.onToolEnd();
 		audioRouter.onToolExecutionEnd(event.isError === true, ctx);
+		if (state.enabled) clearGentleShellChangesWidget(ctx);
 		if (
+			state.enabled &&
 			state.workingTreeEnabled &&
 			event.isError !== true &&
 			shouldRefreshWorkingTree(event.toolName)
@@ -658,10 +928,12 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 		}
 	});
 	pi.on("session_shutdown", () => {
+		codexUsageAbort?.abort();
+		codexUsageAbort = undefined;
+		state.codexUsage = { kind: "idle" };
 		cancelOsdyRefreshes();
 		controller.onShutdown();
 		stopResponsive();
-		if (sessionContext) disableOsdyPi(sessionContext, state);
 		workingTreeState.tui = undefined;
 		sessionContext = undefined;
 	});
@@ -670,10 +942,15 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 		stopResponsive();
 		sessionContext = ctx;
 		const editorSettings = await editorSettingsStore.load();
+		if (sessionContext !== ctx) return;
+		state.fallbackEditorFactory = ctx.ui.getEditorComponent();
+		state.enabled = editorSettings.enabled;
 		state.editorMode = editorSettings.editorMode;
 		state.workingTreeEnabled = editorSettings.workingTreeEnabled;
+		state.headerVariant = editorSettings.headerVariant;
+		state.mascot = editorSettings.mascot;
 		workingTreeState.enabled = editorSettings.workingTreeEnabled;
-		if (sessionContext !== ctx) return;
+		if (!state.enabled) return;
 		claimOsdyVisualLayer(
 			pi,
 			ctx,
@@ -683,18 +960,19 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 			pendingOsdyRefreshes,
 			() => sessionContext === ctx,
 		);
-		responsiveCoordinator = createResponsiveCoordinator(
-			pi,
-			ctx,
-			state,
-			workingTreeState,
-		);
-		responsiveCoordinator.start();
+		startResponsive();
 		if (state.workingTreeEnabled) {
 			void refreshWorkingTree(pi, ctx, workingTreeState);
 		}
+		void refreshCurrentCodexUsage(ctx);
 	});
 
+	registerUsageCommand(
+		pi,
+		state,
+		() => sessionContext,
+		refreshCurrentCodexUsage,
+	);
 	registerCommand(
 		pi,
 		state,