@narumitw/pi-btw 0.55.4 → 0.56.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-btw",
-	"version": "0.55.4",
+	"version": "0.56.1",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",
@@ -23,9 +23,6 @@
 			"./dist/index.ts"
 		]
 	},
-	"piExtension": {
-		"lifecycle": "stable"
-	},
 	"scripts": {
 		"build": "node scripts/build-runtime.mjs",
 		"check": "npm run build && biome check . && npm run typecheck",
@@ -34,10 +31,10 @@
 		"prepack": "npm run build"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.10",
-		"@earendil-works/pi-ai": "0.84.3",
-		"@earendil-works/pi-coding-agent": "0.84.3",
-		"@earendil-works/pi-tui": "0.84.3",
+		"@biomejs/biome": "2.5.11",
+		"@earendil-works/pi-ai": "0.84.4",
+		"@earendil-works/pi-coding-agent": "0.84.4",
+		"@earendil-works/pi-tui": "0.84.4",
 		"esbuild": "0.28.2",
 		"typescript": "7.0.2"
 	},

package/src/btw.ts

@@ -33,6 +33,7 @@ import {
 } from "./menu.js";
 import {
 	type BtwSettings,
+	effectiveFullscreenCopyOnSelect,
 	effectiveRememberThinkingLevelChanges,
 	parseBtwModelReference,
 	readBtwSettings,
@@ -193,7 +194,7 @@ export async function loadBtwThinkingLevel(
 
 	options.warn?.(
 		sanitizeSingleLine(
-			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", and boolean rememberThinkingLevelChanges. Using current Pi thinking level.`,
+			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", boolean rememberThinkingLevelChanges, and boolean fullscreenCopyOnSelect. Using current Pi thinking level.`,
 		),
 	);
 	return currentThinkingLevel;
@@ -314,31 +315,35 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 			const startingTurnCount = state?.thread.turns.length ?? 0;
 
 			try {
-				await runFullscreen(ctx, (fullscreenCtx) => {
-					if (!state) {
-						const createdAt = Date.now();
-						state = {
-							id: `btw-${nextThreadNumber}`,
-							thread: createSideThread(
-								selectedConversationContext ??
-									buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
-							),
-							thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
-							createdAt,
-							updatedAt: createdAt,
-						};
-						nextThreadNumber += 1;
-					}
-					return runThread({
-						initialQuestion: question || undefined,
-						selected: resolution.selected,
-						thinkingLevel: state.thinkingLevel,
-						rememberThinkingLevelChanges:
-							!sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
-						state,
-						ctx: fullscreenCtx,
-					});
-				});
+				await runFullscreen(
+					ctx,
+					(fullscreenCtx) => {
+						if (!state) {
+							const createdAt = Date.now();
+							state = {
+								id: `btw-${nextThreadNumber}`,
+								thread: createSideThread(
+									selectedConversationContext ??
+										buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
+								),
+								thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
+								createdAt,
+								updatedAt: createdAt,
+							};
+							nextThreadNumber += 1;
+						}
+						return runThread({
+							initialQuestion: question || undefined,
+							selected: resolution.selected,
+							thinkingLevel: state.thinkingLevel,
+							rememberThinkingLevelChanges:
+								!sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
+							state,
+							ctx: fullscreenCtx,
+						});
+					},
+					{ copyOnSelect: effectiveFullscreenCopyOnSelect(settings) },
+				);
 			} finally {
 				if (state?.title && state.thread.turns.length > 0) {
 					if (state.thread.turns.length > startingTurnCount) {

package/src/fullscreen-ui.ts

@@ -30,6 +30,7 @@ type BtwCustomFactory<T> = (
 type BtwFullscreenTui = TUI & {
 	flash?: (message: string, durationMs?: number) => void;
 	setLayoutRoot(component: Component | undefined): void;
+	addInputListenerBeforeAll?(listener: TuiInputListener): () => void;
 	addInputListenerBeforeViewport?(listener: TuiInputListener): () => void;
 };
 
@@ -37,17 +38,28 @@ export interface BtwFullscreenLayoutComponent extends Component {
 	getFullscreenLayout(): Component;
 }
 
-export type BtwFullscreenTuiFactory = (parent: TUI, theme: Theme) => BtwFullscreenTui;
+export interface BtwFullscreenOptions {
+	copyOnSelect?: boolean;
+}
+
+export type BtwFullscreenTuiFactory = (
+	parent: TUI,
+	theme: Theme,
+	keybindings: KeybindingsManager,
+	options: BtwFullscreenOptions,
+) => BtwFullscreenTui;
 
 export interface BtwFullscreenDependencies {
 	createTui?: BtwFullscreenTuiFactory;
 	openUrl?: (url: string) => void;
 	copyToClipboard?: (text: string) => Promise<void>;
+	manualSelectionCopySupported?: boolean;
 }
 
 export type RunBtwFullscreen = <T>(
 	ctx: ExtensionCommandContext,
 	run: (ctx: ExtensionCommandContext) => Promise<T>,
+	options?: BtwFullscreenOptions,
 ) => Promise<T>;
 
 type FullscreenOutcome<T> = { kind: "completed"; value: T } | { kind: "failed"; error: unknown };
@@ -62,14 +74,23 @@ class FullscreenUiDisposedError extends Error {
 export async function runBtwFullscreen<T>(
 	ctx: ExtensionCommandContext,
 	run: (ctx: ExtensionCommandContext) => Promise<T>,
+	options: BtwFullscreenOptions = {},
 	dependencies: BtwFullscreenDependencies = {},
 ): Promise<T> {
 	const createTui =
 		dependencies.createTui ??
-		((parent: TUI, theme: Theme) =>
+		((
+			parent: TUI,
+			theme: Theme,
+			keybindings: KeybindingsManager,
+			fullscreenOptions: BtwFullscreenOptions,
+		) =>
 			createBtwFullscreenTui(
 				parent,
 				theme,
+				keybindings,
+				fullscreenOptions.copyOnSelect ?? true,
+				dependencies.manualSelectionCopySupported ?? hasManualSelectionCopyApi(),
 				dependencies.openUrl ?? openUrlInBrowser,
 				dependencies.copyToClipboard ?? copyToHostClipboard,
 			));
@@ -94,6 +115,7 @@ export async function runBtwFullscreen<T>(
 					done(value);
 				},
 				createTui,
+				options,
 			);
 			return host;
 		},
@@ -114,6 +136,7 @@ export async function runBtwFullscreen<T>(
 }
 
 type BtwInputListeners = {
+	beforeAll: Set<TuiInputListener>;
 	beforeViewport: Set<TuiInputListener>;
 	regular: Set<TuiInputListener>;
 };
@@ -122,7 +145,7 @@ const btwInputListeners = new WeakMap<BtwTuiAltScreen, BtwInputListeners>();
 
 function dispatchBtwInput(listeners: BtwInputListeners, data: string): TuiInputListenerResult {
 	let current = data;
-	for (const group of [listeners.beforeViewport, listeners.regular]) {
+	for (const group of [listeners.beforeAll, listeners.beforeViewport, listeners.regular]) {
 		for (const listener of group) {
 			const result = listener(current);
 			if (result?.consume) return result;
@@ -133,10 +156,15 @@ function dispatchBtwInput(listeners: BtwInputListeners, data: string): TuiInputL
 }
 
 class BtwTuiAltScreen extends TuiAltScreen {
+	hasFocusedOverlay(): boolean {
+		return this.isOverlayFocused();
+	}
+
 	override addInputListener(listener: TuiInputListener): () => void {
 		let listeners = btwInputListeners.get(this);
 		if (!listeners) {
 			const registeredListeners: BtwInputListeners = {
+				beforeAll: new Set(),
 				beforeViewport: new Set(),
 				regular: new Set(),
 			};
@@ -148,6 +176,13 @@ class BtwTuiAltScreen extends TuiAltScreen {
 		return () => listeners.regular.delete(listener);
 	}
 
+	addInputListenerBeforeAll(listener: TuiInputListener): () => void {
+		const listeners = btwInputListeners.get(this);
+		if (!listeners) return super.addInputListener(listener);
+		listeners.beforeAll.add(listener);
+		return () => listeners.beforeAll.delete(listener);
+	}
+
 	addInputListenerBeforeViewport(listener: TuiInputListener): () => void {
 		const listeners = btwInputListeners.get(this);
 		if (!listeners) return super.addInputListener(listener);
@@ -161,33 +196,85 @@ class BtwTuiAltScreen extends TuiAltScreen {
 			super.removeInputListener(listener);
 			return;
 		}
+		listeners.beforeAll.delete(listener);
 		listeners.beforeViewport.delete(listener);
 		listeners.regular.delete(listener);
 	}
 }
 
+const BRACKETED_PASTE_START = "\u001b[200~";
+const BRACKETED_PASTE_END = "\u001b[201~";
+
+function hasManualSelectionCopyApi(): boolean {
+	return (
+		typeof TuiAltScreen.prototype.hasActiveSelection === "function" &&
+		typeof TuiAltScreen.prototype.copyActiveSelectionToClipboard === "function"
+	);
+}
+
 function createBtwFullscreenTui(
 	parent: TUI,
 	theme: Theme,
+	keybindings: KeybindingsManager,
+	copyOnSelect: boolean,
+	manualSelectionCopySupported: boolean,
 	openUrl: (url: string) => void,
 	copyToClipboard: (text: string) => Promise<void>,
 ): BtwFullscreenTui {
+	if (!copyOnSelect && !manualSelectionCopySupported) {
+		throw new Error(
+			"Manual fullscreen selection copying is unavailable in this Pi version; update Pi or enable automatic selection copying.",
+		);
+	}
 	const styleSearchMatch = (text: string) =>
 		theme.bg("searchMatchBg", theme.fg("searchMatchText", text));
-	return new BtwTuiAltScreen(parent.terminal, parent.getShowHardwareCursor(), undefined, {
-		mouse: true,
-		searchMatchStyle: (text) => theme.underline(styleSearchMatch(text)),
-		searchCurrentMatchStyle: (text) => theme.bold(theme.inverse(styleSearchMatch(text))),
-		openUrl,
-		copySelection: async (text) => {
-			try {
-				await copyToClipboard(text);
-				return true;
-			} catch {
-				return false;
-			}
+	const fullscreen = new BtwTuiAltScreen(
+		parent.terminal,
+		parent.getShowHardwareCursor(),
+		undefined,
+		{
+			mouse: true,
+			copyOnSelect,
+			searchMatchStyle: (text) => theme.underline(styleSearchMatch(text)),
+			searchCurrentMatchStyle: (text) => theme.bold(theme.inverse(styleSearchMatch(text))),
+			openUrl,
+			copySelection: async (text) => {
+				try {
+					await copyToClipboard(text);
+					return true;
+				} catch {
+					return false;
+				}
+			},
 		},
-	});
+	);
+	if (!copyOnSelect) {
+		let isInBracketedPaste = false;
+		fullscreen.addInputListenerBeforeViewport((data) => {
+			const wasInBracketedPaste = isInBracketedPaste;
+			const startsBracketedPaste = data.includes(BRACKETED_PASTE_START);
+			if (startsBracketedPaste) isInBracketedPaste = true;
+			if (isInBracketedPaste && data.includes(BRACKETED_PASTE_END)) {
+				isInBracketedPaste = false;
+			}
+			if (
+				wasInBracketedPaste ||
+				startsBracketedPaste ||
+				fullscreen.hasFocusedOverlay() ||
+				isKeyRelease(data) ||
+				!keybindings.matches(data, "app.message.copy")
+			) {
+				return undefined;
+			}
+			if (!fullscreen.hasActiveSelection()) {
+				fullscreen.flash("No selection to copy");
+				return { consume: true };
+			}
+			void fullscreen.copyActiveSelectionToClipboard().catch(() => fullscreen.flash("Copy failed"));
+			return { consume: true };
+		});
+	}
+	return fullscreen;
 }
 
 // Pi does not export its browser opener, so mirror its shell-free launcher for this isolated TUI.
@@ -213,9 +300,10 @@ class BtwFullscreenHost<T> implements Component {
 	private disposed = false;
 	private finished = false;
 	private parentStopped = false;
-	private parentRestarted = false;
+	private parentRestoreAttempted = false;
 	private fullscreenCreated = false;
 	private fullscreenStopped = false;
+	private parentRestoreQueued = false;
 	private cleanupError: unknown;
 
 	constructor(
@@ -226,6 +314,7 @@ class BtwFullscreenHost<T> implements Component {
 		private readonly run: (ctx: ExtensionCommandContext) => Promise<T>,
 		private readonly done: (outcome: FullscreenOutcome<T>) => void,
 		private readonly createTui: BtwFullscreenTuiFactory,
+		private readonly options: BtwFullscreenOptions,
 	) {
 		queueMicrotask(() => void this.start());
 	}
@@ -255,11 +344,12 @@ class BtwFullscreenHost<T> implements Component {
 			this.parent.stop({ preserveScreen: true });
 			this.parentStopped = true;
 			if (this.disposed) throw new FullscreenUiDisposedError();
-			this.fullscreen = this.createTui(this.parent, this.theme);
+			this.fullscreen = this.createTui(this.parent, this.theme, this.keybindings, this.options);
 			this.fullscreenCreated = true;
 			this.fullscreen.start();
 			// Waiting for the custom promise would leave follow-up keys bound to the side TUI.
 			const addHardCancelListener =
+				this.fullscreen.addInputListenerBeforeAll?.bind(this.fullscreen) ??
 				this.fullscreen.addInputListenerBeforeViewport?.bind(this.fullscreen) ??
 				this.fullscreen.addInputListener.bind(this.fullscreen);
 			this.removeHardCancelListener = addHardCancelListener((data) => {
@@ -267,7 +357,11 @@ class BtwFullscreenHost<T> implements Component {
 				try {
 					this.hardCancelActiveCustom?.();
 				} finally {
-					this.restoreParent();
+					// ProcessTerminal.stop() destroys its active input buffer. Defer only the
+					// physical handoff so Windows can finish dispatching this Ctrl+C first.
+					// Pi has no public input injection, so do not replay bytes already coalesced
+					// behind the hard-cancel key.
+					this.queueParentRestore();
 				}
 				return { consume: true };
 			});
@@ -287,9 +381,23 @@ class BtwFullscreenHost<T> implements Component {
 		this.done(outcome);
 	}
 
+	private queueParentRestore(): void {
+		if (this.parentRestoreQueued || this.parentRestoreAttempted) return;
+		this.parentRestoreQueued = true;
+		queueMicrotask(() => {
+			this.parentRestoreQueued = false;
+			this.restoreParent();
+		});
+	}
+
 	private restoreParent(): void {
-		this.removeHardCancelListener?.();
+		const removeHardCancelListener = this.removeHardCancelListener;
 		this.removeHardCancelListener = undefined;
+		try {
+			removeHardCancelListener?.();
+		} catch (error) {
+			this.cleanupError ??= error;
+		}
 		if (this.fullscreenCreated && !this.fullscreenStopped) {
 			this.fullscreenStopped = true;
 			try {
@@ -298,7 +406,7 @@ class BtwFullscreenHost<T> implements Component {
 				this.cleanupError ??= error;
 			}
 		}
-		if (!this.parentStopped || this.parentRestarted) return;
+		if (!this.parentStopped || this.parentRestoreAttempted) return;
 		const parentOverlay = this.parentOverlay;
 		this.parentOverlay = undefined;
 		try {
@@ -307,8 +415,8 @@ class BtwFullscreenHost<T> implements Component {
 			this.cleanupError ??= error;
 		}
 		try {
+			this.parentRestoreAttempted = true;
 			this.parent.start();
-			this.parentRestarted = true;
 			this.parent.renderNow(false);
 		} catch (error) {
 			this.cleanupError ??= error;

package/src/menu.ts

@@ -9,6 +9,7 @@ import {
 	type BtwSettings,
 	type BtwSettingsPatch,
 	btwSettingsPath,
+	effectiveFullscreenCopyOnSelect,
 	effectiveRememberThinkingLevelChanges,
 	readBtwSettings,
 	type UpdateBtwSettingsOptions,
@@ -48,7 +49,13 @@ export type BtwCommandMenuResult =
 	| { kind: "resume"; threadId: string };
 
 type BtwMenuScreen = "main" | "resume" | "settings" | "invalid";
-type BtwMenuAction = "start" | "start-tree" | "resume" | "set-thinking" | "set-remember";
+type BtwMenuAction =
+	| "start"
+	| "start-tree"
+	| "resume"
+	| "set-thinking"
+	| "set-remember"
+	| "set-fullscreen-copy";
 const SAME_AS_MAIN_THREAD = "Same as main thread";
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 
@@ -111,6 +118,7 @@ export async function showBtwCommandMenu(
 				title: "Pi BTW",
 				lines: [
 					`Thinking: ${displayThinkingSummary(state.settings)} · Remember changes: ${displayRememberSummary(state.settings)}`,
+					`Copy on select: ${effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off"}`,
 				],
 				items: [
 					{
@@ -138,7 +146,7 @@ export async function showBtwCommandMenu(
 					{
 						id: "settings",
 						label: "Settings",
-						description: "Choose pi-btw thinking level and fixed-level shortcut memory",
+						description: "Choose thinking, shortcut memory, and selection copying",
 						to: state.kind === "invalid" ? "invalid" : "settings",
 					},
 				],
@@ -178,6 +186,15 @@ export async function showBtwCommandMenu(
 						values: ["On", "Off"],
 						action: "set-remember",
 					},
+					{
+						id: "fullscreenCopyOnSelect",
+						label: "Copy selection automatically",
+						description:
+							"Copy mouse selections immediately instead of with the configured copy key.",
+						currentValue: effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off",
+						values: ["On", "Off"],
+						action: "set-fullscreen-copy",
+					},
 				],
 			}),
 			invalid: ({ state }) => ({
@@ -240,6 +257,21 @@ export async function showBtwCommandMenu(
 					return { kind: "rejected" };
 				}
 			},
+			"set-fullscreen-copy": async ({ value, signal }) => {
+				if (value !== "On" && value !== "Off") return { kind: "rejected" };
+				try {
+					await updateSettings(
+						{ fullscreenCopyOnSelect: value === "On" },
+						{ settingsPath, signal },
+					);
+					if (signal.aborted) return { kind: "rejected" };
+					notifySafely(ctx, `Copy selection automatically: ${value}.`, "info");
+					return { kind: "stay" };
+				} catch (error) {
+					if (!signal.aborted) notifySaveFailure(ctx, error);
+					return { kind: "rejected" };
+				}
+			},
 		},
 	});
 

package/src/settings.ts

@@ -6,6 +6,7 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { BTW_THINKING_LEVELS, type BtwThinkingLevel } from "./side-thread.js";
 
 export const BTW_SETTINGS_FILE = "pi-btw.json";
+export const DEFAULT_FULLSCREEN_COPY_ON_SELECT = true;
 export const DEFAULT_REMEMBER_THINKING_LEVEL_CHANGES = true;
 const MAX_SETTINGS_BYTES = 64 * 1024;
 
@@ -13,6 +14,7 @@ export interface BtwSettings {
 	model?: string;
 	thinkingLevel?: BtwThinkingLevel;
 	rememberThinkingLevelChanges?: boolean;
+	fullscreenCopyOnSelect?: boolean;
 }
 
 export type BtwSettingsLoadResult =
@@ -23,6 +25,7 @@ export type BtwSettingsLoadResult =
 export interface BtwSettingsPatch {
 	thinkingLevel?: BtwThinkingLevel;
 	rememberThinkingLevelChanges?: boolean;
+	fullscreenCopyOnSelect?: boolean;
 }
 
 export interface UpdateBtwSettingsOptions {
@@ -58,6 +61,11 @@ export function normalizeBtwSettings(value: unknown): BtwSettings | undefined {
 		if (typeof remember !== "boolean") return undefined;
 		settings.rememberThinkingLevelChanges = remember;
 	}
+	if (Object.hasOwn(value, "fullscreenCopyOnSelect")) {
+		const copyOnSelect = Reflect.get(value, "fullscreenCopyOnSelect");
+		if (typeof copyOnSelect !== "boolean") return undefined;
+		settings.fullscreenCopyOnSelect = copyOnSelect;
+	}
 	return settings;
 }
 
@@ -70,6 +78,10 @@ export function parseBtwModelReference(
 	return { provider: reference.slice(0, separator), modelId: reference.slice(separator + 1) };
 }
 
+export function effectiveFullscreenCopyOnSelect(settings: BtwSettings): boolean {
+	return settings.fullscreenCopyOnSelect ?? DEFAULT_FULLSCREEN_COPY_ON_SELECT;
+}
+
 export function effectiveRememberThinkingLevelChanges(settings: BtwSettings): boolean {
 	return settings.rememberThinkingLevelChanges ?? DEFAULT_REMEMBER_THINKING_LEVEL_CHANGES;
 }
@@ -233,6 +245,10 @@ function applyBtwSettingsPatch(
 	if (Object.hasOwn(patch, "rememberThinkingLevelChanges")) {
 		updated.rememberThinkingLevelChanges = patch.rememberThinkingLevelChanges;
 	}
+	if (Object.hasOwn(patch, "fullscreenCopyOnSelect")) {
+		if (patch.fullscreenCopyOnSelect === undefined) delete updated.fullscreenCopyOnSelect;
+		else updated.fullscreenCopyOnSelect = patch.fullscreenCopyOnSelect;
+	}
 	return updated;
 }