pi-copy-message 3.0.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 4.0.0 - 2026-10-01
+
+- Require Pi 1.0.0 and pin the official 1.0.0 development cohort.
+- Use the native canonical projection for latest-message copies, honoring context edits and compaction while retaining raw historical numbered/picker/user copies and legacy response snapshots.
+- Verify clipboard text before reporting success; keep Pi's complete native/platform/OSC 52 write fallback chain and warn when delivery is unverified, empty, mismatched or remote.
+- Cancel pending pickers on session/tree/shutdown lifecycle changes; suppress stale completion notifications.
+- Add native mouse navigation/copy with restored editor focus and safe isolated clipboard/SDK lifecycle regression coverage.
+
 ## 3.0.0 - 2026-09-26
 
 - Require Node.js 24.15 or newer for repository tooling; `.nvmrc` pins 24.21.0 and `packageManager` is npm 12.1.0.

package/README.md

@@ -16,8 +16,8 @@ A [pi](https://github.com/earendil-works/pi-mono) extension that adds `/copy-mes
 - Supports type-to-filter search across role and message text, with `time:<term>` for timestamp search
 - Supports Home/End jumps for oldest/newest visible messages
 - Uses Pi's configured selection bindings for navigation, copy, and cancel
-- Uses Pi's clipboard implementation, including its OSC 52 terminal fallback
-- Includes fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`
+- Keeps Pi's platform clipboard writes and OSC 52 fallback, but reports success only after local text readback
+- Includes fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`, using Pi's canonical active context
 - Supports direct numbered copies like `/copy-message 3`
 - Supports metadata copies with `--with-meta`, `--with-metadata`, or `--with-role`
 
@@ -35,7 +35,7 @@ Or install it directly from GitHub with pi:
 pi install https://github.com/fitchmultz/pi-copy-message
 ```
 
-Restart Pi after installing or updating extension code or dependencies. The maintained fork's `/reload` refreshes resources and reinitializes cached code; it does not apply code updates.
+Use `/reload` after updating extension code on current official Pi and the maintained fork. Restart Pi after changing dependencies or the host runtime.
 
 If you prefer to load it directly from a local checkout during development:
 
@@ -109,6 +109,8 @@ Copy with role and timestamp metadata instead of raw text only:
 ## Behavior notes
 
 - Entry IDs are hidden from the picker.
+- Mouse wheel navigates; clicking a message copies it and returns keyboard focus to the unchanged draft.
+- Session replacement, tree navigation, shutdown and reload cancel pending pickers without stale-context notifications.
 - The picker caps visible rows and scrolls instead of filling the screen.
 - Search preserves your original selected message and restores it when the search is cleared.
 - General search does not match timestamps; use `time:<term>` when you want to search by displayed time.
@@ -116,15 +118,17 @@ Copy with role and timestamp metadata instead of raw text only:
 - Filter labels honor the active pi theme.
 - Selection key hints show the active Pi bindings. Configured selection actions take precedence if they collide with the picker's filter, preview, or format shortcuts.
 - Only custom messages with `display: true` can appear or be copied from current `custom_message` entries or legacy message-wrapped entries; visible ones can be toggled with `Alt+C`.
-- Copy notifications include the role and a short preview so you can verify what was copied.
+- A verified local copy notification includes the role and a short preview. Unavailable, empty or mismatched readback warns instead of claiming success; rejected writes report an error. Remote terminal delivery via OSC 52 cannot be verified, even when the remote machine's local clipboard matches.
+- Native clipboard reads are preferred where available. Bounded platform readers preserve exact text, including newlines; the extension never replaces Pi's working write fallback chain.
+- `latest` uses Pi's canonical session projection, honoring context edits, omissions and compaction. Numbered selectors, the picker and `/copy-user` retain raw active-branch history, including older pre-compaction messages.
 - `/copy-message latest` and numbered selectors include user, assistant, and visible custom messages by default while hiding tool/bash messages. `Alt+C` only affects the picker. If only hidden messages exist, `latest` falls back to the newest message so the command still does something useful.
 - `/copy-message` with no direct selector requires interactive TUI mode because the picker is a custom TUI component.
 - Direct commands such as `/copy-user`, `/copy-message latest`, and `/copy-message 3` do not require TUI mode, though non-UI modes may not display notifications.
 
 ## Compatibility
 
-- Declared Pi floor: 0.84.0. Qualified on official Pi 0.87.1 and the maintained fork's `main` (not a claim that every later release has been tested).
-- The maintained fork persists in-progress assistant snapshots and context-window boundaries; the picker coalesces those so each response appears once. Official Pi writes neither, and the same code handles both.
+- Requires Pi 1.0.0 or later. Development and standalone/packed qualification use the official 1.0.0 cohort; a maintained fork must be qualified at its actual supported revision, not by version-string equivalence.
+- The picker coalesces legacy in-progress assistant snapshots within their context-window boundaries so each response appears once. Current official Pi and the maintained fork no longer write those legacy boundaries.
 - Android/Termux clipboard writes use Pi's normal fallback chain, including OSC 52 when native clipboard commands are unavailable.
 - Pi includes `Ctrl+X` for copying the latest assistant response; this extension remains useful for searchable history, other roles, metadata, and direct selectors.
 - Node.js `>=24.15.0`. `.nvmrc` pins Node 24.21.0 for local development.
@@ -138,7 +142,7 @@ npm ci
 npm run check # node --test + tsc --noEmit + pack dry-run
 ```
 
-No production build or `prepare` is required. Tests run TypeScript directly with Node's type stripping, so source must stay erasable (`erasableSyntaxOnly`). Qualification uses the selected host installed in this checkout's dependency graph. The tests cover picker behavior and formatting without clipboard writes; native clipboard delivery, including Android/Termux and OSC 52, requires separate platform qualification.
+No production build or `prepare` is required. Tests run TypeScript directly with Node's type stripping, so source must stay erasable (`erasableSyntaxOnly`). Qualification uses the selected host installed in this checkout's dependency graph. The tests cover formatting, native command execution, canonical context and branch selection, both TUI modes, pointer focus and pending-picker disposal. Native addon interception and an isolated command PATH keep test clipboard writes in temporary fixture files, never the operator clipboard. Actual Android/Termux, Windows/WSL and remote terminal delivery still require platform qualification.
 
 `package-lock.json` must only reference `registry.npmjs.org`; a test fails on private-registry URLs. Behind a registry proxy that rewrites tarball URLs, refresh the lock from public metadata and install through the proxy:
 

package/extensions/copy-message.ts

@@ -1,6 +1,8 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { copyToClipboard, type ExtensionAPI, type ExtensionCommandContext, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem, TuiMode } from "@earendil-works/pi-tui";
-import { decodeKittyPrintable, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { decodeKittyPrintable, getNativeClipboard, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
 
 const MAX_VISIBLE_MESSAGES = 8;
 const MAX_PEEK_LINES = 16;
@@ -169,6 +171,17 @@ export function collectCopyableMessages(ctx: { sessionManager: { getBranch(): un
 	});
 }
 
+function collectProjectedMessages(ctx: ExtensionCommandContext): CopyableMessage[] {
+	const entries = ctx.sessionManager.buildSessionProjection().entries.flatMap(({ sourceEntry, messages }): unknown[] => {
+		// Retain saved fork boundaries for legacy response-snapshot coalescing.
+		if ((sourceEntry.type as string) === "context_window") return [sourceEntry];
+		return messages
+			.filter((message) => !(sourceEntry.type === "compaction" && message.role === "system"))
+			.map((message) => ({ ...sourceEntry, type: "message", message }));
+	});
+	return collectCopyableMessages({ sessionManager: { getBranch: () => entries } });
+}
+
 export type MostRecentUserMessageResult =
 	| { kind: "message"; message: CopyableMessage }
 	| { kind: "no-user-message" }
@@ -414,6 +427,7 @@ export class CopyMessagePickerState {
 	peek = false;
 	private searchAnchorId: string | undefined;
 	private readonly messages: CopyableMessage[];
+	private firstVisibleIndex = 0;
 
 	constructor(messages: CopyableMessage[], initialFormat: CopyFormat = "raw") {
 		this.messages = messages;
@@ -435,6 +449,7 @@ export class CopyMessagePickerState {
 		const maxVisible = Math.min(this.visibleMessages.length, MAX_VISIBLE_MESSAGES);
 		const start = maxVisible === 0 ? 0 : Math.max(0, Math.min(this.selectedIndex - maxVisible + 1, this.visibleMessages.length - maxVisible));
 		const end = Math.min(this.visibleMessages.length, start + maxVisible);
+		this.firstVisibleIndex = start;
 		const hasCustomMessages = this.messages.some((message) => message.role === "custom");
 		const userState = filterLabel(theme, "user", this.visibility.showUser, "warning");
 		const assistantState = filterLabel(theme, "assistant", this.visibility.showAssistant, "accent");
@@ -584,6 +599,20 @@ export class CopyMessagePickerState {
 		return "none";
 	}
 
+	handleMouse(event: TuiMouseEvent): PickerInputResult {
+		if (event.type === "wheel" && event.wheelDelta) {
+			this.move(event.wheelDelta < 0 ? -1 : 1);
+			return "render";
+		}
+		if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) return "none";
+		const row = event.y - 2; // The message list follows the title and spacer.
+		if (row < 0 || row >= MAX_VISIBLE_MESSAGES) return "none";
+		const index = this.firstVisibleIndex + row;
+		if (!this.visibleMessages[index]) return "none";
+		this.selectedIndex = index;
+		return event.type === "click" ? "copy" : "render";
+	}
+
 	private refreshMessages(preferredId?: string) {
 		const selectedId = preferredId ?? this.visibleMessages[this.selectedIndex]?.id;
 		this.visibleMessages = filteredMessages(this.messages, this.visibility, this.search);
@@ -660,28 +689,33 @@ export function copyArgumentCompletions(prefix: string, includeSelectors: boolea
 	return items.length > 0 ? items : null;
 }
 
-async function pickMessage(ctx: ExtensionCommandContext, messages: CopyableMessage[], initialFormat: CopyFormat) {
+async function pickMessage(ctx: ExtensionCommandContext, messages: CopyableMessage[], initialFormat: CopyFormat, signal: AbortSignal) {
+	if (signal.aborted) return null;
 	return ctx.ui.custom<{ message: CopyableMessage; text: string } | null>((tui, theme, keybindings, done) => {
 		const state = new CopyMessagePickerState(messages, initialFormat);
+		const abort = () => done(null);
+		if (signal.aborted) abort();
+		else signal.addEventListener("abort", abort, { once: true });
+		const act = (result: PickerInputResult) => {
+			if (result === "copy") {
+				const selected = state.selectedMessage();
+				const text = state.selectedCopyText();
+				done(selected && text !== undefined ? { message: selected, text } : null);
+			} else if (result === "cancel") done(null);
+			else if (result === "render") tui.requestRender();
+		};
 		return {
 			render(width: number) {
 				return state.render(width, theme, keybindings, tui.mode);
 			},
 			invalidate() {},
-			handleInput(data: string) {
-				const result = state.handleInput(data, keybindings);
-				if (result === "copy") {
-					const selected = state.selectedMessage();
-					const text = state.selectedCopyText();
-					done(selected && text !== undefined ? { message: selected, text } : null);
-					return;
-				}
-				if (result === "cancel") {
-					done(null);
-					return;
-				}
-				if (result === "render") tui.requestRender();
+			handleInput(data: string) { act(state.handleInput(data, keybindings)); },
+			handleMouse(event) {
+				const result = state.handleMouse(event);
+				act(result);
+				if (result !== "none") return { handled: true, focus: result === "render" };
 			},
+			dispose: () => signal.removeEventListener("abort", abort),
 		};
 	});
 }
@@ -690,74 +724,132 @@ function copyNotificationText(selected: CopyableMessage): string {
 	return `Copied ${roleLabel(selected.role)} message: “${compactPreview(selected.text, 48)}”`;
 }
 
-async function copySelectedMessage(ctx: Pick<ExtensionCommandContext, "ui">, selected: CopyableMessage, text = selected.text) {
+const runClipboardReader = promisify(execFile);
+
+async function readCopiedText(expected: string): Promise<string | null | undefined> {
+	if (process.platform !== "linux") {
+		try {
+			const text = await getNativeClipboard()?.getText();
+			if (text !== undefined) return text;
+		} catch {
+			// The platform command fallback can still work if the native helper fails.
+		}
+	}
+	const commands: [string, string[]][] = [];
+	const windowsRead = ["-NoProfile", "-Command", "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false); [Console]::Write((Get-Clipboard -Raw))"];
+	if (process.platform === "darwin") commands.push(["pbpaste", []]);
+	else if (process.platform === "win32") commands.push(["powershell", windowsRead]);
+	else {
+		if (process.env.TERMUX_VERSION) commands.push(["termux-clipboard-get", []]);
+		if (process.env.WAYLAND_DISPLAY) commands.push(["wl-paste", ["--no-newline", "--type", "text"]]);
+		if (process.env.DISPLAY) commands.push(["xclip", ["-selection", "clipboard", "-out"]], ["xsel", ["--clipboard", "--output"]]);
+		if (!commands.length && (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)) commands.push(["powershell.exe", windowsRead]);
+	}
+	for (const [command, args] of commands) {
+		try {
+			const { stdout } = await runClipboardReader(command, args, {
+				encoding: "utf8", timeout: 3000, maxBuffer: Math.max(1024 * 1024, Buffer.byteLength(expected) + 4096),
+			});
+			return stdout || null;
+		} catch {
+			// Try the next platform reader; never expose clipboard contents on failure.
+		}
+	}
+	return undefined;
+}
+
+type Notify = ExtensionCommandContext["ui"]["notify"];
+
+async function copySelectedMessage(notify: Notify, selected: CopyableMessage, text = selected.text) {
 	try {
 		await copyToClipboard(text);
-		ctx.ui.notify(copyNotificationText(selected), "info");
+		const actual = await readCopiedText(text);
+		const remote = Boolean(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.MOSH_CONNECTION);
+		if (actual === text && !remote) notify(copyNotificationText(selected), "info");
+		else notify(
+			actual === text ? "Local clipboard verified; remote terminal clipboard delivery is unverified."
+				: "Clipboard command completed, but delivery could not be verified.",
+			"warning",
+		);
 	} catch (error) {
-		ctx.ui.notify(error instanceof Error ? error.message : "Failed to copy to clipboard", "error");
+		notify(error instanceof Error ? error.message : "Failed to copy to clipboard", "error");
 	}
 }
 
-async function copyMostRecentUserMessage(ctx: Pick<ExtensionCommandContext, "sessionManager" | "ui">, format: CopyFormat) {
+async function copyMostRecentUserMessage(ctx: Pick<ExtensionCommandContext, "sessionManager">, notify: Notify, format: CopyFormat) {
 	const result = getMostRecentUserMessage(ctx);
 	if (result.kind === "no-user-message") {
-		ctx.ui.notify("No user messages found", "warning");
+		notify("No user messages found", "warning");
 		return;
 	}
 	if (result.kind === "no-text") {
-		ctx.ui.notify("No user message text found", "warning");
+		notify("No user message text found", "warning");
 		return;
 	}
-
-	await copySelectedMessage(ctx, result.message, formatMessageForCopy(result.message, format));
+	await copySelectedMessage(notify, result.message, formatMessageForCopy(result.message, format));
 }
 
-export default function copyMessageExtension(pi: Pick<ExtensionAPI, "registerCommand">) {
+export default function copyMessageExtension(pi: Pick<ExtensionAPI, "registerCommand" | "on">) {
+	let generation = 0;
+	let pickerAbort: AbortController | undefined;
+	const reset = () => {
+		generation++;
+		pickerAbort?.abort();
+		pickerAbort = undefined;
+	};
+	pi.on("session_start", reset);
+	pi.on("session_shutdown", reset);
+	pi.on("session_tree", reset);
+	const notifications = (ctx: ExtensionCommandContext): Notify => {
+		const current = generation;
+		return (message, type) => { if (current === generation) ctx.ui.notify(message, type); };
+	};
 	pi.registerCommand("copy-message", {
 		description: "Select a session message and copy its text to the clipboard",
 		getArgumentCompletions: (argumentPrefix) => copyArgumentCompletions(argumentPrefix, true),
 		handler: async (args, ctx) => {
+			const notify = notifications(ctx);
 			const parsedArgs = parseCopyArgs(args);
-			const messages = collectCopyableMessages(ctx);
+			const messages = parsedArgs.selector === "latest" ? collectProjectedMessages(ctx) : collectCopyableMessages(ctx);
 			if (messages.length === 0) {
-				ctx.ui.notify("No copyable messages found in the current branch", "error");
+				notify("No copyable messages found in the current branch", "error");
 				return;
 			}
-
 			if (parsedArgs.selector === "latest") {
 				const latestVisible = latestDefaultMessage(messages);
-				if (latestVisible) await copySelectedMessage(ctx, latestVisible, formatMessageForCopy(latestVisible, parsedArgs.format));
+				if (latestVisible) await copySelectedMessage(notify, latestVisible, formatMessageForCopy(latestVisible, parsedArgs.format));
 				return;
 			}
-
 			if (typeof parsedArgs.selector === "object") {
 				const selected = messageByDefaultNumber(messages, parsedArgs.selector.number);
 				if (!selected) {
-					ctx.ui.notify(`No default visible message #${parsedArgs.selector.number} (found ${defaultVisibleMessages(messages).length})`, "warning");
+					notify(`No default visible message #${parsedArgs.selector.number} (found ${defaultVisibleMessages(messages).length})`, "warning");
 					return;
 				}
-				await copySelectedMessage(ctx, selected, formatMessageForCopy(selected, parsedArgs.format));
+				await copySelectedMessage(notify, selected, formatMessageForCopy(selected, parsedArgs.format));
 				return;
 			}
-
 			if (ctx.mode !== "tui") {
-				ctx.ui.notify("/copy-message requires interactive TUI mode unless you pass latest/last/newest or a message number", "error");
+				notify("/copy-message requires interactive TUI mode unless you pass latest/last/newest or a message number", "error");
 				return;
 			}
-
-			const selected = await pickMessage(ctx, messages, parsedArgs.format);
-			if (!selected) return;
-
-			await copySelectedMessage(ctx, selected.message, selected.text);
+			pickerAbort?.abort();
+			const controller = new AbortController();
+			pickerAbort = controller;
+			try {
+				const selected = await pickMessage(ctx, messages, parsedArgs.format, controller.signal);
+				if (!selected || controller.signal.aborted) return;
+				await copySelectedMessage(notify, selected.message, selected.text);
+			} finally {
+				if (pickerAbort === controller) pickerAbort = undefined;
+			}
 		},
 	});
-
 	pi.registerCommand("copy-user", {
 		description: "Copy the most recent user message to the clipboard",
 		getArgumentCompletions: (argumentPrefix) => copyArgumentCompletions(argumentPrefix, false),
 		handler: async (args, ctx) => {
-			await copyMostRecentUserMessage(ctx, parseCopyArgs(args).format);
+			await copyMostRecentUserMessage(ctx, notifications(ctx), parseCopyArgs(args).format);
 		},
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-copy-message",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Pi extension with a searchable TUI picker for copying raw session messages",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
   "license": "MIT",
@@ -45,8 +45,8 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@earendil-works/pi-tui": "0.87.1",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
     "@types/node": "24.19.0",
     "typescript": "7.0.2"
   },
@@ -55,7 +55,7 @@
       "./extensions"
     ]
   },
-  "packageManager": "npm@12.1.0",
+  "packageManager": "npm@12.2.0",
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"