gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.538325aea

package/packages/gsd-agent-modes/src/modes/interactive/components/oauth-selector.ts

@@ -0,0 +1,122 @@
+import type { OAuthProviderInterface } from "@gsd/pi-ai";
+import { getOAuthProviders } from "@gsd/pi-ai/oauth";
+import { Container, Spacer, TruncatedText } from "@gsd/pi-tui";
+import { getKeybindings } from "../../../pi-tui-compat.js";
+import type { AuthStorage } from "@gsd/agent-types";
+import { theme } from "../../../theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+
+/**
+ * Component that renders an OAuth provider selector
+ */
+export class OAuthSelectorComponent extends Container {
+	private listContainer: Container;
+	private allProviders: OAuthProviderInterface[] = [];
+	private selectedIndex: number = 0;
+	private mode: "login" | "logout";
+	private authStorage: AuthStorage;
+	private onSelectCallback: (providerId: string) => void;
+	private onCancelCallback: () => void;
+
+	constructor(
+		mode: "login" | "logout",
+		authStorage: AuthStorage,
+		onSelect: (providerId: string) => void,
+		onCancel: () => void,
+	) {
+		super();
+
+		this.mode = mode;
+		this.authStorage = authStorage;
+		this.onSelectCallback = onSelect;
+		this.onCancelCallback = onCancel;
+
+		// Load all OAuth providers
+		this.loadProviders();
+
+		// Add top border
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+
+		// Add title
+		const title = mode === "login" ? "Select provider to login:" : "Select provider to logout:";
+		this.addChild(new TruncatedText(theme.bold(title)));
+		this.addChild(new Spacer(1));
+
+		// Create list container
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+
+		this.addChild(new Spacer(1));
+
+		// Add bottom border
+		this.addChild(new DynamicBorder());
+
+		// Initial render
+		this.updateList();
+	}
+
+	private loadProviders(): void {
+		this.allProviders = getOAuthProviders();
+	}
+
+	private updateList(): void {
+		this.listContainer.clear();
+
+		for (let i = 0; i < this.allProviders.length; i++) {
+			const provider = this.allProviders[i];
+			if (!provider) continue;
+
+			const isSelected = i === this.selectedIndex;
+
+			// Check if user is logged in for this provider
+			const credentials = this.authStorage.get(provider.id);
+			const isLoggedIn = credentials?.type === "oauth";
+			const statusIndicator = isLoggedIn ? theme.fg("success", " ✓ logged in") : "";
+
+			let line: string;
+			if (isSelected) {
+				const prefix = theme.fg("accent", "→ ");
+				const text = theme.fg("accent", provider.name);
+				line = prefix + text + statusIndicator;
+			} else {
+				const text = `  ${provider.name}`;
+				line = text + statusIndicator;
+			}
+
+			this.listContainer.addChild(new TruncatedText(line, 0, 0));
+		}
+
+		// Show "no providers" if empty
+		if (this.allProviders.length === 0) {
+			const message =
+				this.mode === "login" ? "No OAuth providers available" : "No OAuth providers logged in. Use /login first.";
+			this.listContainer.addChild(new TruncatedText(theme.fg("muted", `  ${message}`), 0, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+		// Up arrow (wrap)
+		if (kb.matches(keyData, "selectUp")) {
+			this.selectedIndex = this.selectedIndex === 0 ? this.allProviders.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+		}
+		// Down arrow (wrap)
+		else if (kb.matches(keyData, "selectDown")) {
+			this.selectedIndex = this.selectedIndex === this.allProviders.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+		}
+		// Enter
+		else if (kb.matches(keyData, "selectConfirm")) {
+			const selectedProvider = this.allProviders[this.selectedIndex];
+			if (selectedProvider) {
+				this.onSelectCallback(selectedProvider.id);
+			}
+		}
+		// Escape or Ctrl+C
+		else if (kb.matches(keyData, "selectCancel")) {
+			this.onCancelCallback();
+		}
+	}
+}

package/packages/gsd-agent-modes/src/modes/interactive/components/provider-manager.ts

@@ -0,0 +1,210 @@
+/**
+ * TUI component for managing provider configurations.
+ * Shows providers with auth status, discovery support, and model counts.
+ */
+
+import {
+	Container,
+	type Focusable,
+	Spacer,
+	Text,
+	type TUI,
+} from "@gsd/pi-tui";
+import { getKeybindings } from "../../../pi-tui-compat.js";
+import type { AuthStorage } from "@gsd/agent-types";
+// getDiscoverableProviders and ModelsJsonWriter removed in pi-coding-agent 0.67.2
+import { providerDisplayName } from "./model-selector.js";
+import type { ModelRegistry } from "@gsd/agent-types";
+import { theme } from "../../../theme.js";
+import { rawKeyHint } from "./keybinding-hints.js";
+
+interface ProviderInfo {
+	name: string;
+	hasAuth: boolean;
+	supportsDiscovery: boolean;
+	modelCount: number;
+}
+
+export class ProviderManagerComponent extends Container implements Focusable {
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+	}
+
+	private providers: ProviderInfo[] = [];
+	private selectedIndex = 0;
+	private listContainer: Container;
+	private tui: TUI;
+	private authStorage: AuthStorage;
+	private modelRegistry: ModelRegistry;
+	private onDone: () => void;
+	private onDiscover: (provider: string) => void;
+	private onSetupAuth: (provider: string) => void;
+	private confirmingRemove = false;
+	private hintsContainer: Container;
+
+	constructor(
+		tui: TUI,
+		authStorage: AuthStorage,
+		modelRegistry: ModelRegistry,
+		onDone: () => void,
+		onDiscover: (provider: string) => void,
+		onSetupAuth?: (provider: string) => void,
+	) {
+		super();
+
+		this.tui = tui;
+		this.authStorage = authStorage;
+		this.modelRegistry = modelRegistry;
+		this.onDone = onDone;
+		this.onDiscover = onDiscover;
+		this.onSetupAuth = onSetupAuth ?? (() => {});
+
+		// Header
+		this.addChild(new Text(theme.fg("accent", "Provider Manager"), 0, 0));
+		this.addChild(new Spacer(1));
+
+		// Hints
+		this.hintsContainer = new Container();
+		this.addChild(this.hintsContainer);
+		this.updateHints();
+		this.addChild(new Spacer(1));
+
+		// List
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+
+		this.loadProviders();
+		this.updateList();
+	}
+
+	private loadProviders(): void {
+		// getDiscoverableProviders removed in 0.67.2 — treat all providers as non-discoverable
+		const allModels = this.modelRegistry.getAll();
+
+		// Group models by provider
+		const providerModelCounts = new Map<string, number>();
+		for (const model of allModels) {
+			providerModelCounts.set(model.provider, (providerModelCounts.get(model.provider) ?? 0) + 1);
+		}
+
+		this.providers = Array.from(providerModelCounts.keys())
+			.sort()
+			.map((name) => ({
+				name,
+				hasAuth: this.authStorage.hasAuth(name),
+				supportsDiscovery: false,
+				modelCount: providerModelCounts.get(name) ?? 0,
+			}));
+		this.clampSelectedIndex();
+	}
+
+	private clampSelectedIndex(): void {
+		if (this.providers.length === 0) {
+			this.selectedIndex = 0;
+			return;
+		}
+		this.selectedIndex = Math.min(this.selectedIndex, this.providers.length - 1);
+	}
+
+	private updateHints(): void {
+		this.hintsContainer.clear();
+		if (this.confirmingRemove) {
+			const hints = [
+				rawKeyHint("r", "confirm removal"),
+				rawKeyHint("esc", "cancel"),
+			].join("  ");
+			this.hintsContainer.addChild(new Text(hints, 0, 0));
+		} else {
+			const hints = [
+				rawKeyHint("enter", "setup auth"),
+				rawKeyHint("d", "discover"),
+				rawKeyHint("r", "remove auth"),
+				rawKeyHint("esc", "close"),
+			].join("  ");
+			this.hintsContainer.addChild(new Text(hints, 0, 0));
+		}
+	}
+
+	private updateList(): void {
+		this.listContainer.clear();
+
+		for (let i = 0; i < this.providers.length; i++) {
+			const p = this.providers[i];
+			const isSelected = i === this.selectedIndex;
+
+			const authBadge = p.hasAuth ? theme.fg("success", "[auth]") : theme.fg("muted", "[no auth]");
+			const discoveryBadge = p.supportsDiscovery ? theme.fg("accent", "[discovery]") : "";
+			const countBadge = theme.fg("muted", `(${p.modelCount} models)`);
+
+			const prefix = isSelected ? theme.fg("accent", "> ") : "  ";
+			const nameText = isSelected ? theme.fg("accent", providerDisplayName(p.name)) : providerDisplayName(p.name);
+
+			const parts = [prefix, nameText, " ", authBadge];
+			if (discoveryBadge) parts.push(" ", discoveryBadge);
+			parts.push(" ", countBadge);
+
+			this.listContainer.addChild(new Text(parts.join(""), 0, 0));
+		}
+
+		if (this.providers.length === 0) {
+			this.listContainer.addChild(new Text(theme.fg("muted", "  No providers configured"), 0, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+
+		if (kb.matches(keyData, "selectUp")) {
+			if (this.providers.length === 0) return;
+			this.selectedIndex = this.selectedIndex === 0 ? this.providers.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "selectDown")) {
+			if (this.providers.length === 0) return;
+			this.selectedIndex = this.selectedIndex === this.providers.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "selectCancel")) {
+			if (this.confirmingRemove) {
+				this.confirmingRemove = false;
+				this.updateHints();
+				this.tui.requestRender();
+			} else {
+				this.onDone();
+			}
+		} else if (keyData === "d" || keyData === "D") {
+			const provider = this.providers[this.selectedIndex];
+			if (provider?.supportsDiscovery) {
+				this.onDiscover(provider.name);
+			}
+		} else if (keyData === "r" || keyData === "R") {
+			const provider = this.providers[this.selectedIndex];
+			if (provider?.hasAuth) {
+				if (this.confirmingRemove) {
+					this.confirmingRemove = false;
+					this.authStorage.remove(provider.name);
+					// ModelsJsonWriter removed in 0.67.2 — auth removal is sufficient
+					this.modelRegistry.refresh();
+					this.loadProviders();
+					this.updateHints();
+					this.updateList();
+					this.tui.requestRender();
+				} else {
+					this.confirmingRemove = true;
+					this.updateHints();
+					this.tui.requestRender();
+				}
+			}
+		} else if (kb.matches(keyData, "selectConfirm")) {
+			// Enter key → initiate auth setup for the selected provider (#3579)
+			const provider = this.providers[this.selectedIndex];
+			if (provider) {
+				this.onSetupAuth(provider.name);
+			}
+		}
+	}
+}

package/packages/gsd-agent-modes/src/modes/interactive/components/scoped-models-selector.ts

@@ -0,0 +1,342 @@
+import type { Api, Model } from "@gsd/pi-ai";
+import { providerDisplayName } from "./model-selector.js";
+import {
+	Container,
+	type Focusable,
+	fuzzyFilter,
+	Input,
+	Key,
+	matchesKey,
+	Spacer,
+	Text,
+} from "@gsd/pi-tui";
+import { getKeybindings } from "../../../pi-tui-compat.js";
+import { theme } from "../../../theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+
+// EnabledIds: null = all enabled (no filter), string[] = explicit ordered list
+type EnabledIds = string[] | null;
+
+function isEnabled(enabledIds: EnabledIds, id: string): boolean {
+	return enabledIds === null || enabledIds.includes(id);
+}
+
+function toggle(enabledIds: EnabledIds, id: string): EnabledIds {
+	if (enabledIds === null) return [id]; // First toggle: start with only this one
+	const index = enabledIds.indexOf(id);
+	if (index >= 0) return [...enabledIds.slice(0, index), ...enabledIds.slice(index + 1)];
+	return [...enabledIds, id];
+}
+
+function enableAll(enabledIds: EnabledIds, allIds: string[], targetIds?: string[]): EnabledIds {
+	if (enabledIds === null) return null; // Already all enabled
+	const targets = targetIds ?? allIds;
+	const result = [...enabledIds];
+	for (const id of targets) {
+		if (!result.includes(id)) result.push(id);
+	}
+	return result.length === allIds.length ? null : result;
+}
+
+function clearAll(enabledIds: EnabledIds, allIds: string[], targetIds?: string[]): EnabledIds {
+	if (enabledIds === null) {
+		return targetIds ? allIds.filter((id) => !targetIds.includes(id)) : [];
+	}
+	const targets = new Set(targetIds ?? enabledIds);
+	return enabledIds.filter((id) => !targets.has(id));
+}
+
+function move(enabledIds: EnabledIds, allIds: string[], id: string, delta: number): EnabledIds {
+	const list = enabledIds ?? [...allIds];
+	const index = list.indexOf(id);
+	if (index < 0) return list;
+	const newIndex = index + delta;
+	if (newIndex < 0 || newIndex >= list.length) return list;
+	const result = [...list];
+	[result[index], result[newIndex]] = [result[newIndex], result[index]];
+	return result;
+}
+
+function getSortedIds(enabledIds: EnabledIds, allIds: string[]): string[] {
+	if (enabledIds === null) return allIds;
+	const enabledSet = new Set(enabledIds);
+	return [...enabledIds, ...allIds.filter((id) => !enabledSet.has(id))];
+}
+
+interface ModelItem {
+	fullId: string;
+	model: Model<Api>;
+	enabled: boolean;
+}
+
+export interface ModelsConfig {
+	allModels: Model<Api>[];
+	enabledModelIds: Set<string>;
+	/** true if enabledModels setting is defined (empty = all enabled) */
+	hasEnabledModelsFilter: boolean;
+}
+
+export interface ModelsCallbacks {
+	/** Called when a model is toggled (session-only, no persist) */
+	onModelToggle: (modelId: string, enabled: boolean) => void;
+	/** Called when user wants to persist current selection to settings */
+	onPersist: (enabledModelIds: string[]) => void;
+	/** Called when user enables all models. Returns list of all model IDs. */
+	onEnableAll: (allModelIds: string[]) => void;
+	/** Called when user clears all models */
+	onClearAll: () => void;
+	/** Called when user toggles all models for a provider. Returns affected model IDs. */
+	onToggleProvider: (provider: string, modelIds: string[], enabled: boolean) => void;
+	onCancel: () => void;
+}
+
+/**
+ * Component for enabling/disabling models for Ctrl+P cycling.
+ * Changes are session-only until explicitly persisted with Ctrl+S.
+ */
+export class ScopedModelsSelectorComponent extends Container implements Focusable {
+	private modelsById: Map<string, Model<Api>> = new Map();
+	private allIds: string[] = [];
+	private enabledIds: EnabledIds = null;
+	private filteredItems: ModelItem[] = [];
+	private selectedIndex = 0;
+	private searchInput: Input;
+
+	// Focusable implementation - propagate to searchInput for IME cursor positioning
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+		this.searchInput.focused = value;
+	}
+	private listContainer: Container;
+	private footerText: Text;
+	private callbacks: ModelsCallbacks;
+	private maxVisible = 15;
+	private isDirty = false;
+
+	constructor(config: ModelsConfig, callbacks: ModelsCallbacks) {
+		super();
+		this.callbacks = callbacks;
+
+		for (const model of config.allModels) {
+			const fullId = `${model.provider}/${model.id}`;
+			this.modelsById.set(fullId, model);
+			this.allIds.push(fullId);
+		}
+
+		this.enabledIds = config.hasEnabledModelsFilter ? [...config.enabledModelIds] : null;
+		this.filteredItems = this.buildItems();
+
+		// Header
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("accent", theme.bold("Model Configuration")), 0, 0));
+		this.addChild(new Text(theme.fg("muted", "Session-only. Ctrl+S to save to settings."), 0, 0));
+		this.addChild(new Spacer(1));
+
+		// Search input
+		this.searchInput = new Input();
+		this.addChild(this.searchInput);
+		this.addChild(new Spacer(1));
+
+		// List container
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+
+		// Footer hint
+		this.addChild(new Spacer(1));
+		this.footerText = new Text(this.getFooterText(), 0, 0);
+		this.addChild(this.footerText);
+
+		this.addChild(new DynamicBorder());
+		this.updateList();
+	}
+
+	private buildItems(): ModelItem[] {
+		// Filter out IDs that no longer have a corresponding model (e.g., after logout)
+		return getSortedIds(this.enabledIds, this.allIds)
+			.filter((id) => this.modelsById.has(id))
+			.map((id) => ({
+				fullId: id,
+				model: this.modelsById.get(id)!,
+				enabled: isEnabled(this.enabledIds, id),
+			}));
+	}
+
+	private getFooterText(): string {
+		const enabledCount = this.enabledIds?.length ?? this.allIds.length;
+		const allEnabled = this.enabledIds === null;
+		const countText = allEnabled ? "all enabled" : `${enabledCount}/${this.allIds.length} enabled`;
+		const parts = ["Enter toggle", "^A all", "^X clear", "^P provider", `${process.platform === "darwin" ? "⌥↑↓" : "Alt+↑↓"} reorder`, "^S save", countText];
+		return this.isDirty
+			? theme.fg("dim", `  ${parts.join(" · ")} `) + theme.fg("warning", "(unsaved)")
+			: theme.fg("dim", `  ${parts.join(" · ")}`);
+	}
+
+	private refresh(): void {
+		const query = this.searchInput.getValue();
+		const items = this.buildItems();
+		this.filteredItems = query ? fuzzyFilter(items, query, (i) => `${i.model.id} ${i.model.provider}`) : items;
+		this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredItems.length - 1));
+		this.updateList();
+		this.footerText.setText(this.getFooterText());
+	}
+
+	private updateList(): void {
+		this.listContainer.clear();
+
+		if (this.filteredItems.length === 0) {
+			this.listContainer.addChild(new Text(theme.fg("muted", "  No matching models"), 0, 0));
+			return;
+		}
+
+		const startIndex = Math.max(
+			0,
+			Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible),
+		);
+		const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+		const allEnabled = this.enabledIds === null;
+
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.filteredItems[i]!;
+			const isSelected = i === this.selectedIndex;
+			const prefix = isSelected ? theme.fg("accent", "→ ") : "  ";
+			const modelText = isSelected ? theme.fg("accent", item.model.id) : item.model.id;
+			const providerBadge = theme.fg("muted", ` [${providerDisplayName(item.model.provider)}]`);
+			const status = allEnabled ? "" : item.enabled ? theme.fg("success", " ✓") : theme.fg("dim", " ✗");
+			this.listContainer.addChild(new Text(`${prefix}${modelText}${providerBadge}${status}`, 0, 0));
+		}
+
+		// Add scroll indicator if needed
+		if (startIndex > 0 || endIndex < this.filteredItems.length) {
+			this.listContainer.addChild(
+				new Text(theme.fg("muted", `  (${this.selectedIndex + 1}/${this.filteredItems.length})`), 0, 0),
+			);
+		}
+
+		if (this.filteredItems.length > 0) {
+			const selected = this.filteredItems[this.selectedIndex];
+			this.listContainer.addChild(new Spacer(1));
+			this.listContainer.addChild(new Text(theme.fg("muted", `  Model Name: ${selected.model.name}`), 0, 0));
+		}
+	}
+
+	handleInput(data: string): void {
+		const kb = getKeybindings();
+
+		// Navigation
+		if (kb.matches(data, "selectUp")) {
+			if (this.filteredItems.length === 0) return;
+			this.selectedIndex = this.selectedIndex === 0 ? this.filteredItems.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+			return;
+		}
+		if (kb.matches(data, "selectDown")) {
+			if (this.filteredItems.length === 0) return;
+			this.selectedIndex = this.selectedIndex === this.filteredItems.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+			return;
+		}
+
+		// Alt+Up/Down - Reorder enabled models
+		if (matchesKey(data, Key.alt("up")) || matchesKey(data, Key.alt("down"))) {
+			const item = this.filteredItems[this.selectedIndex];
+			if (item && isEnabled(this.enabledIds, item.fullId)) {
+				const delta = matchesKey(data, Key.alt("up")) ? -1 : 1;
+				const enabledList = this.enabledIds ?? this.allIds;
+				const currentIndex = enabledList.indexOf(item.fullId);
+				const newIndex = currentIndex + delta;
+				// Only move if within bounds
+				if (newIndex >= 0 && newIndex < enabledList.length) {
+					this.enabledIds = move(this.enabledIds, this.allIds, item.fullId, delta);
+					this.isDirty = true;
+					this.selectedIndex += delta;
+					this.refresh();
+				}
+			}
+			return;
+		}
+
+		// Toggle on Enter
+		if (matchesKey(data, Key.enter)) {
+			const item = this.filteredItems[this.selectedIndex];
+			if (item) {
+				const wasAllEnabled = this.enabledIds === null;
+				this.enabledIds = toggle(this.enabledIds, item.fullId);
+				this.isDirty = true;
+				if (wasAllEnabled) this.callbacks.onClearAll();
+				this.callbacks.onModelToggle(item.fullId, isEnabled(this.enabledIds, item.fullId));
+				this.refresh();
+			}
+			return;
+		}
+
+		// Ctrl+A - Enable all (filtered if search active, otherwise all)
+		if (matchesKey(data, Key.ctrl("a"))) {
+			const targetIds = this.searchInput.getValue() ? this.filteredItems.map((i) => i.fullId) : undefined;
+			this.enabledIds = enableAll(this.enabledIds, this.allIds, targetIds);
+			this.isDirty = true;
+			this.callbacks.onEnableAll(targetIds ?? this.allIds);
+			this.refresh();
+			return;
+		}
+
+		// Ctrl+X - Clear all (filtered if search active, otherwise all)
+		if (matchesKey(data, Key.ctrl("x"))) {
+			const targetIds = this.searchInput.getValue() ? this.filteredItems.map((i) => i.fullId) : undefined;
+			this.enabledIds = clearAll(this.enabledIds, this.allIds, targetIds);
+			this.isDirty = true;
+			this.callbacks.onClearAll();
+			this.refresh();
+			return;
+		}
+
+		// Ctrl+P - Toggle provider of current item
+		if (matchesKey(data, Key.ctrl("p"))) {
+			const item = this.filteredItems[this.selectedIndex];
+			if (item) {
+				const provider = item.model.provider;
+				const providerIds = this.allIds.filter((id) => this.modelsById.get(id)!.provider === provider);
+				const allEnabled = providerIds.every((id) => isEnabled(this.enabledIds, id));
+				this.enabledIds = allEnabled
+					? clearAll(this.enabledIds, this.allIds, providerIds)
+					: enableAll(this.enabledIds, this.allIds, providerIds);
+				this.isDirty = true;
+				this.callbacks.onToggleProvider(provider, providerIds, !allEnabled);
+				this.refresh();
+			}
+			return;
+		}
+
+		// Ctrl+S - Save/persist to settings
+		if (matchesKey(data, Key.ctrl("s"))) {
+			this.callbacks.onPersist(this.enabledIds ?? [...this.allIds]);
+			this.isDirty = false;
+			this.footerText.setText(this.getFooterText());
+			return;
+		}
+
+		// Ctrl+C - always cancel immediately
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.callbacks.onCancel();
+			return;
+		}
+
+		// Escape - cancel
+		if (matchesKey(data, Key.escape)) {
+			this.callbacks.onCancel();
+			return;
+		}
+
+		// Pass everything else to search input
+		this.searchInput.handleInput(data);
+		this.refresh();
+	}
+
+	getSearchInput(): Input {
+		return this.searchInput;
+	}
+}