@oh-my-pi/pi-coding-agent 15.12.2 → 15.12.4

package/src/lsp/types.ts

@@ -1,5 +1,5 @@
 import type { ptree } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 
 // =============================================================================
 // Tool Schema

package/src/main.ts

@@ -25,7 +25,6 @@ import type { Args } from "./cli/args";
 import { applyExtensionFlags, type ExtensionFlagSink } from "./cli/extension-flags";
 import { processFileArguments } from "./cli/file-processor";
 import { buildInitialMessage } from "./cli/initial-message";
-import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { applyStartupCwd } from "./cli/startup-cwd";
 import { findConfigFile } from "./config";
@@ -920,30 +919,6 @@ export async function runRootCommand(
 		process.exit(0);
 	}
 
-	if (parsedArgs.listModels !== undefined) {
-		const settingsInstance = await logger.time("settings:init:list-models", Settings.init, {
-			cwd: getProjectDir(),
-			configFiles: parsedArgs.config,
-		});
-		await modelRegistry.refresh("online");
-		const cliExtensionPaths = parsedArgs.noExtensions
-			? []
-			: [...(parsedArgs.extensions ?? []), ...(parsedArgs.hooks ?? [])];
-		const settingsExtensions = settingsInstance.get("extensions") ?? [];
-		const disabledExtensionIds = settingsInstance.get("disabledExtensions") ?? [];
-		const searchPattern = typeof parsedArgs.listModels === "string" ? parsedArgs.listModels : undefined;
-		await runListModelsCommand({
-			modelRegistry,
-			cwd: getProjectDir(),
-			additionalExtensionPaths: cliExtensionPaths,
-			settingsExtensions,
-			disabledExtensionIds,
-			disableExtensionDiscovery: Boolean(parsedArgs.noExtensions),
-			searchPattern,
-		});
-		process.exit(0);
-	}
-
 	if (parsedArgs.export) {
 		let result: string;
 		try {

package/src/mcp/config-writer.ts

@@ -67,9 +67,13 @@ export function validateServerName(name: string): string | undefined {
 	if (name.length > 100) {
 		return "Server name is too long (max 100 characters)";
 	}
-	// Check for invalid characters (only allow alphanumeric, dash, underscore, dot)
-	if (!/^[a-zA-Z0-9_.-]+$/.test(name)) {
-		return "Server name can only contain letters, numbers, dash, underscore, and dot";
+	// Check for invalid characters. Colon is allowed so namespaced plugin servers
+	// (e.g. "cloudflare:cloudflare-api" from a Claude Code marketplace plugin) can
+	// be persisted: the runtime already accepts colons in server names (tool names
+	// sanitize them via createMCPToolName) and `/mcp reauth` writes such names back
+	// as a user-config override that shadows the discovered entry.
+	if (!/^[a-zA-Z0-9_.:-]+$/.test(name)) {
+		return "Server name can only contain letters, numbers, dash, underscore, dot, and colon";
 	}
 	return undefined;
 }

package/src/mcp/manager.ts

@@ -643,6 +643,17 @@ export class MCPManager {
 		return this.#sources.get(name) ?? this.#connections.get(name)?._source;
 	}
 
+	/**
+	 * Get the preserved (pre-auth) config for a known server — whether currently
+	 * connected or merely discovered (a connect was attempted but may have failed,
+	 * e.g. an OAuth server that has not been authorized yet). Mirrors the
+	 * reconnect lookup at {@link reconnectServer} so callers like `/mcp reauth`
+	 * can recover a discovered server's config without re-reading config files.
+	 */
+	getServerConfig(name: string): MCPServerConfig | undefined {
+		return this.#connections.get(name)?.config ?? this.#serverConfigs.get(name);
+	}
+
 	/**
 	 * Wait for a connection to complete (or fail).
 	 */

package/src/memories/index.ts

@@ -1071,7 +1071,9 @@ function truncateByApproxTokens(text: string, tokenLimit: number): string {
 
 function computeModelTokenBudget(model: Model, config: MemoryRuntimeConfig): number {
 	const maxTokens =
-		Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : config.fallbackTokenLimit;
+		model.contextWindow !== null && Number.isFinite(model.contextWindow) && model.contextWindow > 0
+			? model.contextWindow
+			: config.fallbackTokenLimit;
 	return Math.max(2048, Math.floor(maxTokens));
 }
 

package/src/memories/storage.ts

@@ -46,10 +46,11 @@ function globalJobKey(cwd: string): string {
 
 export function openMemoryDb(dbPath: string): Database {
 	const db = new Database(dbPath);
+	// Install the busy handler BEFORE any lock-taking statement. See #2421.
+	db.exec("PRAGMA busy_timeout = 5000");
 	db.exec(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
-PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS threads (
 	id TEXT PRIMARY KEY,

package/src/mnemopi/config.ts

@@ -1,8 +1,9 @@
+import { Database } from "bun:sqlite";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { MnemopiOptions } from "@oh-my-pi/pi-mnemopi";
-import { getMemoriesDir } from "@oh-my-pi/pi-utils";
+import { getMemoriesDir, logger } from "@oh-my-pi/pi-utils";
 import type { Settings } from "../config/settings";
-import * as git from "../utils/git";
 
 export type MnemopiLlmMode = "none" | "smol" | "remote";
 
@@ -42,15 +43,18 @@ export function loadMnemopiConfig(settings: Settings, agentDir: string): Mnemopi
 	const configuredDbPath = settings.get("mnemopi.dbPath");
 	const cwd = settings.getCwd();
 	const scoping = settings.get("mnemopi.scoping");
-	const scope = resolveBankScope(settings.get("mnemopi.bank"), cwd, scoping);
+	const dbPath = configuredDbPath ?? path.join(getMemoriesDir(agentDir), "mnemopi", "mnemopi.db");
+	const scope = computeMnemopiBankScope(settings.get("mnemopi.bank"), cwd, scoping);
+	const recallBanks =
+		scoping === "global" ? scope.recallBanks : extendRecallWithLegacyBanks(scope.recallBanks, dbPath, cwd);
 	const llmMode = settings.get("mnemopi.llmMode");
 	return {
-		dbPath: configuredDbPath ?? path.join(getMemoriesDir(agentDir), "mnemopi", "mnemopi.db"),
+		dbPath,
 		baseBank: scope.baseBank,
 		bank: scope.bank,
 		globalBank: scope.globalBank,
 		retainBank: scope.retainBank,
-		recallBanks: scope.recallBanks,
+		recallBanks,
 		scoping,
 		autoRecall: settings.get("mnemopi.autoRecall"),
 		autoRetain: settings.get("mnemopi.autoRetain"),
@@ -86,7 +90,11 @@ export function loadMnemopiConfig(settings: Settings, agentDir: string): Mnemopi
 
 const DEFAULT_SHARED_BANK = "default";
 
-interface MnemopiBankScope {
+// Cap legacy-bank scanning at session start so a pathological banks/
+// directory cannot dominate startup latency.
+const LEGACY_BANK_SCAN_LIMIT = 64;
+
+export interface MnemopiBankScope {
 	baseBank: string;
 	bank: string;
 	globalBank: string;
@@ -94,9 +102,19 @@ interface MnemopiBankScope {
 	recallBanks: readonly string[];
 }
 
-// Mnemopi does not have built-in tag-filtered recall, so `per-project-tagged`
-// maps to a project-local write bank plus a shared recall-visible bank.
-function resolveBankScope(configured: string | undefined, cwd: string, scoping: MnemopiScoping): MnemopiBankScope {
+/**
+ * Resolve write/recall banks for a session.
+ *
+ * Mnemopi has no tag-filtered recall, so `per-project-tagged` maps to a
+ * project-local write bank plus a shared recall-visible bank. The project
+ * bank is derived purely from {@link cwd} — see {@link projectBank} for the
+ * stability contract.
+ */
+export function computeMnemopiBankScope(
+	configured: string | undefined,
+	cwd: string,
+	scoping: MnemopiScoping,
+): MnemopiBankScope {
 	const project = projectBank(configured, cwd);
 	const globalBank = sharedBank(configured);
 	switch (scoping) {
@@ -131,8 +149,17 @@ function sharedBank(configured: string | undefined): string {
 	return sanitizeBankName(configured) ?? DEFAULT_SHARED_BANK;
 }
 
+/**
+ * Derive the per-project bank id from `cwd` alone.
+ *
+ * Earlier versions resolved the enclosing git root before hashing, which
+ * made the bank id unstable: removing or adding a `.git` anywhere above the
+ * cwd repointed the same conversation directory to a different bank and
+ * fragmented memories (#2412). The git lookup is gone here; the rescue path
+ * for already-fragmented installs lives in {@link extendRecallWithLegacyBanks}.
+ */
 function projectBank(configured: string | undefined, cwd: string): string {
-	const projectRoot = git.repo.resolveSync(cwd)?.repoRoot ?? path.resolve(cwd);
+	const projectRoot = path.resolve(cwd || ".");
 	const project = projectBankSegment(projectRoot);
 	const base = sanitizeBankName(configured);
 	return limitBankName(base ? `${base}-${project}` : project);
@@ -140,7 +167,64 @@ function projectBank(configured: string | undefined, cwd: string): string {
 
 function projectBankSegment(projectRoot: string): string {
 	const project = sanitizeBankName(path.basename(projectRoot)) ?? "default";
-	return limitBankName(`${project}-${Bun.hash(path.resolve(projectRoot)).toString(36)}`);
+	return limitBankName(`${project}-${Bun.hash(projectRoot).toString(36)}`);
+}
+
+/**
+ * Discover sibling banks under `<dbDir>/banks/` whose `working_memory` rows
+ * already carry the active `cwd` in `metadata_json.$.cwd`, and add them to
+ * the recall set. This rescues memories stranded by a previous, less-stable
+ * bank derivation (#2412) without changing the write target — only recall is
+ * widened.
+ *
+ * Robust by design: a missing banks directory, unreadable bank dir, or
+ * corrupt SQLite file is silently skipped. Scanning is capped at
+ * {@link LEGACY_BANK_SCAN_LIMIT} to bound startup cost.
+ */
+export function extendRecallWithLegacyBanks(
+	resolved: readonly string[],
+	dbPath: string,
+	cwd: string,
+): readonly string[] {
+	const banksDir = path.join(path.dirname(dbPath), "banks");
+	const cwdAbs = path.resolve(cwd || ".");
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(banksDir, { withFileTypes: true });
+	} catch {
+		return resolved;
+	}
+	const have = new Set(resolved);
+	const extras: string[] = [];
+	let scanned = 0;
+	for (const entry of entries) {
+		if (!entry.isDirectory() || have.has(entry.name)) continue;
+		if (scanned >= LEGACY_BANK_SCAN_LIMIT) break;
+		scanned++;
+		const candidate = path.join(banksDir, entry.name, "mnemopi.db");
+		if (bankHasCwd(candidate, cwdAbs)) extras.push(entry.name);
+	}
+	return extras.length === 0 ? resolved : [...resolved, ...extras];
+}
+
+function bankHasCwd(dbPath: string, cwd: string): boolean {
+	let db: Database | undefined;
+	try {
+		db = new Database(dbPath, { readonly: true });
+		const row = db
+			.query("SELECT 1 FROM working_memory WHERE json_extract(metadata_json, '$.cwd') = ? LIMIT 1")
+			.get(cwd);
+		return row !== null;
+	} catch (error) {
+		logger.debug("Mnemopi: legacy bank probe failed", { dbPath, error: String(error) });
+		return false;
+	} finally {
+		try {
+			db?.close();
+		} catch {
+			// nothing to do — read-only handle.
+		}
+	}
 }
 
 function sanitizeBankName(value: string | undefined): string | undefined {

package/src/modes/acp/acp-agent.ts

@@ -31,14 +31,11 @@ import {
 	type ResumeSessionResponse,
 	type SessionConfigOption,
 	type SessionInfo,
-	type SessionModelState,
 	type SessionModeState,
 	type SessionNotification,
 	type SessionUpdate,
 	type SetSessionConfigOptionRequest,
 	type SetSessionConfigOptionResponse,
-	type SetSessionModelRequest,
-	type SetSessionModelResponse,
 	type SetSessionModeRequest,
 	type SetSessionModeResponse,
 	type Usage,
@@ -77,6 +74,7 @@ import { AUTO_THINKING, parseConfiguredThinkingLevel } from "../../thinking";
 import { normalizeLocalScheme } from "../../tools/path-utils";
 import { runResolveInvocation } from "../../tools/resolve";
 import { ToolError } from "../../tools/tool-errors";
+import { getVisibleThinkingText } from "../../utils/thinking-display";
 import { createAcpClientBridge } from "./acp-client-bridge";
 import {
 	buildToolCallStartUpdate,
@@ -121,7 +119,6 @@ type PromptQueueState = {
 type PromptLifecycleError = Error & { readonly code: "ACP_SESSION_CLOSED" };
 
 type PromptTurnState = {
-	userMessageId: string;
 	cancelRequested: boolean;
 	settled: boolean;
 	/**
@@ -465,7 +462,6 @@ export class AcpAgent implements Agent {
 		const response: NewSessionResponse = {
 			sessionId: record.session.sessionId,
 			configOptions: this.#buildConfigOptions(record.session),
-			models: this.#buildModelState(record.session),
 			modes: this.#buildModeState(record.session),
 		};
 		this.#scheduleBootstrapUpdates(record.session.sessionId);
@@ -478,7 +474,6 @@ export class AcpAgent implements Agent {
 		await this.#replaySessionHistory(record);
 		const response: LoadSessionResponse = {
 			configOptions: this.#buildConfigOptions(record.session),
-			models: this.#buildModelState(record.session),
 			modes: this.#buildModeState(record.session),
 		};
 		this.#scheduleBootstrapUpdates(record.session.sessionId);
@@ -507,7 +502,6 @@ export class AcpAgent implements Agent {
 		const record = await this.#resumeManagedSession(params.sessionId, params.cwd, params.mcpServers ?? []);
 		const response: ResumeSessionResponse = {
 			configOptions: this.#buildConfigOptions(record.session),
-			models: this.#buildModelState(record.session),
 			modes: this.#buildModeState(record.session),
 		};
 		this.#scheduleBootstrapUpdates(record.session.sessionId);
@@ -520,7 +514,6 @@ export class AcpAgent implements Agent {
 		const response: ForkSessionResponse = {
 			sessionId: record.session.sessionId,
 			configOptions: this.#buildConfigOptions(record.session),
-			models: this.#buildModelState(record.session),
 			modes: this.#buildModeState(record.session),
 		};
 		this.#scheduleBootstrapUpdates(record.session.sessionId);
@@ -588,13 +581,6 @@ export class AcpAgent implements Agent {
 		return { configOptions: this.#buildConfigOptions(record.session) };
 	}
 
-	async unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse> {
-		const record = this.#getSessionRecord(params.sessionId);
-		await this.#setModelById(record.session, params.modelId);
-		await this.#pushConfigOptionUpdate(record);
-		return {};
-	}
-
 	async prompt(params: PromptRequest): Promise<PromptResponse> {
 		const record = this.#getSessionRecord(params.sessionId);
 		const activeTurn = record.promptTurn;
@@ -633,7 +619,6 @@ export class AcpAgent implements Agent {
 			const converted = this.#convertPromptBlocks(params.prompt);
 			const pendingPrompt = Promise.withResolvers<PromptResponse>();
 			record.promptTurn = {
-				userMessageId: params.messageId ?? crypto.randomUUID(),
 				cancelRequested: false,
 				settled: false,
 				cleanup: undefined,
@@ -766,7 +751,6 @@ export class AcpAgent implements Agent {
 						this.#cloneUsageStatistics(record.session.sessionManager.getUsageStatistics()),
 					record.session.sessionManager.getUsageStatistics(),
 				),
-				userMessageId: promptTurn?.userMessageId,
 			});
 			return;
 		}
@@ -844,7 +828,6 @@ export class AcpAgent implements Agent {
 		this.#finishPrompt(record, {
 			stopReason: "cancelled",
 			usage: this.#buildTurnUsage(promptTurn.usageBaseline, record.session.sessionManager.getUsageStatistics()),
-			userMessageId: promptTurn.userMessageId,
 		});
 		return cleanup;
 	}
@@ -1162,7 +1145,6 @@ export class AcpAgent implements Agent {
 			this.#finishPrompt(record, {
 				stopReason: this.#resolveStopReason(event, promptTurn.cancelRequested),
 				usage: this.#buildTurnUsage(promptTurn.usageBaseline, record.session.sessionManager.getUsageStatistics()),
-				userMessageId: promptTurn.userMessageId,
 			});
 		}
 	}
@@ -1385,28 +1367,6 @@ export class AcpAgent implements Agent {
 		return configOptions;
 	}
 
-	#buildModelState(session: AgentSession): SessionModelState | undefined {
-		const models = session.getAvailableModels();
-		if (models.length === 0) {
-			return undefined;
-		}
-
-		const availableModels = models.map(model => ({
-			modelId: this.#toModelId(model),
-			name: model.name,
-			description: `${model.provider}/${model.id}`,
-		}));
-		const currentModelId = session.model ? this.#toModelId(session.model) : availableModels[0]?.modelId;
-		if (!currentModelId) {
-			return undefined;
-		}
-
-		return {
-			availableModels,
-			currentModelId,
-		};
-	}
-
 	#buildThinkingOptions(session: AgentSession): Array<{ value: string; name: string; description?: string }> {
 		return [
 			{ value: THINKING_OFF, name: "Off" },
@@ -1948,17 +1908,14 @@ export class AcpAgent implements Agent {
 					});
 					continue;
 				}
-				if (
-					item.type === "thinking" &&
-					"thinking" in item &&
-					typeof item.thinking === "string" &&
-					item.thinking.length > 0
-				) {
+				if (item.type === "thinking" && "thinking" in item && typeof item.thinking === "string") {
+					const thinking = getVisibleThinkingText(item);
+					if (thinking.length === 0) continue;
 					notifications.push({
 						sessionId,
 						update: {
 							sessionUpdate: "agent_thought_chunk",
-							content: { type: "text", text: item.thinking },
+							content: { type: "text", text: thinking },
 							messageId,
 						},
 					});

package/src/modes/acp/acp-event-mapper.ts

@@ -9,6 +9,7 @@ import type {
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { resolveToCwd } from "../../tools/path-utils";
 import type { TodoStatus } from "../../tools/todo";
+import { hasVisibleThinking } from "../../utils/thinking-display";
 
 interface MessageProgress {
 	textEmitted: boolean;
@@ -256,13 +257,16 @@ function mapAssistantMessageUpdate(
 				progress.textEmitted = true;
 			}
 			break;
-		case "thinking_delta":
+		case "thinking_delta": {
+			const block = event.assistantMessageEvent.partial?.content?.[event.assistantMessageEvent.contentIndex];
+			if (block?.type === "thinking" && !hasVisibleThinking(block)) return [];
 			sessionUpdate = "agent_thought_chunk";
 			text = event.assistantMessageEvent.delta;
 			if (text.length > 0 && progress) {
 				progress.thoughtEmitted = true;
 			}
 			break;
+		}
 		case "done":
 			if (progress?.textEmitted) {
 				return [];

package/src/modes/components/agent-hub.ts

@@ -39,6 +39,7 @@ import type { SessionMessageEntry } from "../../session/session-manager";
 import { parseSessionEntries } from "../../session/session-manager";
 import { createIrcMessageCard } from "../../tools/irc";
 import { replaceTabs, TRUNCATE_LENGTHS, truncateToWidth } from "../../tools/render-utils";
+import { hasVisibleThinking } from "../../utils/thinking-display";
 import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
 import { getEditorTheme, theme } from "../theme/theme";
 import { matchesSelectDown, matchesSelectUp } from "../utils/keybinding-matchers";
@@ -992,7 +993,7 @@ export class AgentHubOverlayComponent extends Container {
 		const hasVisibleAssistantContent = message.content.some(
 			content =>
 				(content.type === "text" && content.text.trim().length > 0) ||
-				(content.type === "thinking" && content.thinking.trim().length > 0),
+				(content.type === "thinking" && hasVisibleThinking(content)),
 		);
 		if (hasVisibleAssistantContent) {
 			// New visible turn content closes the current read run (mirrors rebuild).

package/src/modes/components/assistant-message.ts

@@ -6,6 +6,7 @@ import type { AssistantThinkingRenderer } from "../../extensibility/extensions/t
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { resolveAbortLabel, shouldRenderAbortReason } from "../../session/messages";
 import { getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
+import { getVisibleThinkingText, hasVisibleThinking } from "../../utils/thinking-display";
 
 /**
  * Max lines of a turn-ending provider error rendered inline in the transcript.
@@ -245,7 +246,7 @@ export class AssistantMessageComponent extends Container {
 			if (content.type === "text") {
 				parts.push(content.text.trim() ? "T1" : "T0");
 			} else if (content.type === "thinking") {
-				if (!content.thinking.trim()) parts.push("K0");
+				if (!hasVisibleThinking(content)) parts.push("K0");
 				else if (this.hideThinkingBlock) parts.push("KH");
 				else parts.push("KV");
 			} else {
@@ -284,7 +285,7 @@ export class AssistantMessageComponent extends Container {
 			for (const item of this.#fastPathItems) {
 				if (item.blockType === "thinking") {
 					const content = message.content[item.contentIndex];
-					if (content?.type === "thinking" && content.thinking.trim() !== item.lastText) return false;
+					if (content?.type === "thinking" && getVisibleThinkingText(content) !== item.lastText) return false;
 				}
 			}
 		}
@@ -312,7 +313,7 @@ export class AssistantMessageComponent extends Container {
 			if (item.blockType === "text" && content?.type === "text") {
 				newText = content.text.trim();
 			} else if (item.blockType === "thinking" && content?.type === "thinking") {
-				newText = content.thinking.trim();
+				newText = getVisibleThinkingText(content);
 			} else {
 				// Block at this index is gone or changed type (index shift) — fail closed.
 				this.#fastPathKey = undefined;
@@ -347,7 +348,7 @@ export class AssistantMessageComponent extends Container {
 		const hasVisibleContent = message.content.some(
 			c =>
 				(c.type === "text" && c.text.trim()) ||
-				(!this.hideThinkingBlock && c.type === "thinking" && c.thinking.trim()),
+				(!this.hideThinkingBlock && c.type === "thinking" && hasVisibleThinking(c)),
 		);
 
 		// Render content in order
@@ -362,7 +363,8 @@ export class AssistantMessageComponent extends Container {
 				md.transientRenderCache = this.#lastUpdateTransient;
 				this.#contentContainer.addChild(md);
 				captureItems?.push({ md, contentIndex: i, blockType: "text", lastText: trimmed });
-			} else if (content.type === "thinking" && content.thinking.trim()) {
+			} else if (content.type === "thinking" && hasVisibleThinking(content)) {
+				const thinkingText = getVisibleThinkingText(content);
 				if (this.hideThinkingBlock) {
 					thinkingIndex += 1;
 					continue;
@@ -371,9 +373,8 @@ export class AssistantMessageComponent extends Container {
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
 				const hasVisibleContentAfter = message.content
 					.slice(i + 1)
-					.some(c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
+					.some(c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && hasVisibleThinking(c)));
 
-				const thinkingText = content.thinking.trim();
 				// Thinking traces in thinkingText color, italic
 				const md = new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
 					color: (text: string) => theme.fg("thinkingText", text),

package/src/modes/components/index.ts

@@ -16,6 +16,7 @@ export * from "./hook-message";
 export * from "./hook-selector";
 export * from "./keybinding-hints";
 export * from "./login-dialog";
+export * from "./logout-account-selector";
 export * from "./model-selector";
 export * from "./oauth-selector";
 export * from "./queue-mode-selector";

package/src/modes/components/logout-account-selector.ts

@@ -0,0 +1,130 @@
+import { Container, matchesKey, ScrollView, Spacer, TruncatedText } from "@oh-my-pi/pi-tui";
+import { theme } from "../../modes/theme/theme";
+import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
+import type { LogoutAccount } from "../../slash-commands/helpers/logout";
+import { DynamicBorder } from "./dynamic-border";
+
+const LOGOUT_SELECTOR_MAX_VISIBLE = 10;
+
+/** Account picker for `/logout` after the provider has been selected. */
+export class LogoutAccountSelectorComponent extends Container {
+	#listContainer: Container;
+	#accounts: LogoutAccount[];
+	#selectedIndex = 0;
+	#statusMessage: string | undefined;
+	#onSelectCallback: (account: LogoutAccount) => void;
+	#onCancelCallback: () => void;
+
+	constructor(
+		providerName: string,
+		accounts: LogoutAccount[],
+		onSelect: (account: LogoutAccount) => void,
+		onCancel: () => void,
+	) {
+		super();
+		this.#accounts = accounts;
+		this.#onSelectCallback = onSelect;
+		this.#onCancelCallback = onCancel;
+		const activeIndex = accounts.findIndex(account => account.active);
+		this.#selectedIndex = activeIndex >= 0 ? activeIndex : 0;
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(new TruncatedText(theme.bold(`Select ${providerName} account to log out:`)));
+		this.addChild(new Spacer(1));
+		this.#listContainer = new Container();
+		this.addChild(this.#listContainer);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+		this.#updateList();
+	}
+
+	#updateList(): void {
+		this.#listContainer.clear();
+
+		const total = this.#accounts.length;
+		const maxVisible = LOGOUT_SELECTOR_MAX_VISIBLE;
+		const startIndex =
+			total <= maxVisible
+				? 0
+				: Math.max(0, Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), total - maxVisible));
+		const endIndex = Math.min(startIndex + maxVisible, total);
+
+		const rows: string[] = [];
+		for (let i = startIndex; i < endIndex; i++) {
+			const account = this.#accounts[i];
+			if (!account) continue;
+			const activeTag = account.active ? theme.fg("muted", " (active)") : "";
+			const detail = account.detail ? theme.fg("dim", `  ${account.detail}`) : "";
+			if (i === this.#selectedIndex) {
+				rows.push(`${theme.fg("accent", `${theme.nav.cursor} ${account.label}`)}${activeTag}${detail}`);
+			} else {
+				rows.push(`  ${account.label}${activeTag}${detail}`);
+			}
+		}
+
+		if (rows.length > 0) {
+			const sv = new ScrollView(rows, {
+				height: rows.length,
+				scrollbar: "auto",
+				totalRows: total,
+				theme: { track: text => theme.fg("muted", text), thumb: text => theme.fg("accent", text) },
+			});
+			sv.setScrollOffset(startIndex);
+			this.#listContainer.addChild(sv);
+		}
+
+		if (total === 0) {
+			this.#listContainer.addChild(new TruncatedText(theme.fg("muted", "  No stored accounts to log out"), 0, 0));
+		}
+
+		this.#listContainer.addChild(
+			new TruncatedText(theme.fg("muted", "  ↑/↓ select · ↵ log out account · Esc cancel"), 0, 0),
+		);
+
+		if (this.#statusMessage) {
+			this.#listContainer.addChild(new Spacer(1));
+			this.#listContainer.addChild(new TruncatedText(theme.fg("warning", `  ${this.#statusMessage}`), 0, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		if (matchesSelectCancel(keyData)) {
+			this.#onCancelCallback();
+			return;
+		}
+
+		if (matchesSelectUp(keyData)) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = this.#selectedIndex === 0 ? this.#accounts.length - 1 : this.#selectedIndex - 1;
+			}
+			this.#statusMessage = undefined;
+			this.#updateList();
+		} else if (matchesSelectDown(keyData)) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = this.#selectedIndex === this.#accounts.length - 1 ? 0 : this.#selectedIndex + 1;
+			}
+			this.#statusMessage = undefined;
+			this.#updateList();
+		} else if (matchesKey(keyData, "pageUp")) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = Math.max(0, this.#selectedIndex - LOGOUT_SELECTOR_MAX_VISIBLE);
+			}
+			this.#statusMessage = undefined;
+			this.#updateList();
+		} else if (matchesKey(keyData, "pageDown")) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = Math.min(
+					this.#accounts.length - 1,
+					this.#selectedIndex + LOGOUT_SELECTOR_MAX_VISIBLE,
+				);
+			}
+			this.#statusMessage = undefined;
+			this.#updateList();
+		} else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+			const account = this.#accounts[this.#selectedIndex];
+			if (!account) return;
+			this.#onSelectCallback(account);
+		}
+	}
+}