pi-ui-extend 0.1.1

package/dist/app/input-controller.d.ts

@@ -0,0 +1,60 @@
+import { InputEditor } from "../input-editor.js";
+import type { ExtensionTerminalInputResult } from "./extension-ui-controller.js";
+import type { MouseEvent, ActivePopupMenu } from "./types.js";
+type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
+export type InputControllerHost = {
+    readonly inputEditor: InputEditor;
+    readonly cwd: string;
+    handleExtensionTerminalInput(data: string): ExtensionTerminalInputResult;
+    extensionInputUsesEditor?(): boolean;
+    isShiftPressed?(): boolean;
+    getInput(): string;
+    getDirectPopupMenu(): DirectPopupMenu | undefined;
+    resetRequestHistoryNavigation(): void;
+    resetInputMenuDismissals(): void;
+    render(): void;
+    moveActivePopupMenuSelection(delta: number): boolean;
+    navigateRequestHistory(delta: number): boolean;
+    scrollByLines(delta: number): void;
+    scrollByPage(delta: number): void;
+    handleMouse(event: MouseEvent): void;
+    handleEnter(): void;
+    handleInterrupt(): Promise<void>;
+    handleEscape(): Promise<void>;
+    handleDirectPopupInput(char: string): boolean;
+    autocompleteModel(): boolean;
+    autocompleteThinking(): boolean;
+    autocompleteSlashCommand(): void;
+    toggleVoiceRecording(): void;
+    stop(): Promise<void>;
+};
+export declare class AppInputController {
+    private readonly host;
+    private inputBuffer;
+    private readonly pasteHandler;
+    constructor(host: InputControllerHost);
+    handleChunk(chunk: Buffer): void;
+    private consumeSharedEditorShiftEnter;
+    private drainInputBuffer;
+    private getEscapeSequences;
+    private isPendingEscapeSequence;
+    private consumeEscapeSequence;
+    private consumeCommandBackspaceSequence;
+    private consumeCommandArrowPageSequence;
+    private consumeCommandArrowPageMatch;
+    private consumeTerminalEditShortcutSequence;
+    private consumeTerminalInterruptSequence;
+    private handleArrowUp;
+    private handleArrowDown;
+    private handleArrowLeft;
+    private handleArrowRight;
+    private orderedEditorSelection;
+    private insertInputNewline;
+    private undoInput;
+    private redoInput;
+    private handleEditShortcutChar;
+    private deleteCurrentInputLine;
+    private handleChar;
+    private isShiftPressed;
+}
+export {};

package/dist/app/input-controller.js

@@ -0,0 +1,425 @@
+import { InputPasteHandler } from "./input-paste-handler.js";
+import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
+import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, terminalEditShortcutForControlChar } from "./terminal-edit-shortcuts.js";
+export class AppInputController {
+    host;
+    inputBuffer = "";
+    pasteHandler;
+    constructor(host) {
+        this.host = host;
+        this.pasteHandler = new InputPasteHandler(host);
+    }
+    handleChunk(chunk) {
+        let data = chunk.toString("utf8");
+        if (this.inputBuffer.startsWith("\x1b[<") || data.startsWith("\x1b[<")) {
+            this.inputBuffer += data;
+            this.drainInputBuffer();
+            return;
+        }
+        if (this.consumeSharedEditorShiftEnter(data))
+            return;
+        const extensionInput = this.host.handleExtensionTerminalInput(data);
+        if (extensionInput.consume)
+            return;
+        if (extensionInput.data !== undefined)
+            data = extensionInput.data;
+        if (this.pasteHandler.handlePlainData(data))
+            return;
+        this.inputBuffer += data;
+        this.drainInputBuffer();
+    }
+    consumeSharedEditorShiftEnter(data) {
+        if (this.host.extensionInputUsesEditor?.() !== true)
+            return false;
+        if (this.host.inputEditor.isInBracketedPaste)
+            return false;
+        if (!this.isShiftPressed())
+            return false;
+        if (data !== "\r" && data !== "\n")
+            return false;
+        this.insertInputNewline();
+        return true;
+    }
+    drainInputBuffer() {
+        while (this.inputBuffer.length > 0) {
+            const mouseMatch = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/.exec(this.inputBuffer);
+            if (mouseMatch) {
+                this.inputBuffer = this.inputBuffer.slice(mouseMatch[0].length);
+                this.host.handleMouse({
+                    button: Number(mouseMatch[1]),
+                    x: Number(mouseMatch[2]),
+                    y: Number(mouseMatch[3]),
+                    released: mouseMatch[4] === "m",
+                });
+                continue;
+            }
+            if (this.inputBuffer.startsWith("\x1b[<"))
+                return;
+            const commandBackspaceSequence = this.consumeCommandBackspaceSequence();
+            if (commandBackspaceSequence === "consumed")
+                continue;
+            if (commandBackspaceSequence === "pending")
+                return;
+            const commandArrowPageSequence = this.consumeCommandArrowPageSequence();
+            if (commandArrowPageSequence === "consumed")
+                continue;
+            if (commandArrowPageSequence === "pending")
+                return;
+            const terminalInterruptSequence = this.consumeTerminalInterruptSequence();
+            if (terminalInterruptSequence === "consumed")
+                continue;
+            if (terminalInterruptSequence === "pending")
+                return;
+            const terminalEditShortcutSequence = this.consumeTerminalEditShortcutSequence();
+            if (terminalEditShortcutSequence === "consumed")
+                continue;
+            if (terminalEditShortcutSequence === "pending")
+                return;
+            if (this.consumeEscapeSequence())
+                continue;
+            if (this.isPendingEscapeSequence())
+                return;
+            const char = this.inputBuffer[0];
+            this.inputBuffer = this.inputBuffer.slice(1);
+            if (char)
+                this.handleChar(char);
+        }
+    }
+    getEscapeSequences() {
+        return [
+            ["\x1b[13;2u", () => this.insertInputNewline()],
+            ["\x1b[13;2~", () => this.insertInputNewline()],
+            ["\x1b[27;2;13~", () => this.insertInputNewline()],
+            ["\x1b[13u", () => this.host.handleEnter()],
+            ["\x1b[13;1u", () => this.host.handleEnter()],
+            ["\x1b\r", () => this.insertInputNewline()],
+            ["\x1b\n", () => this.insertInputNewline()],
+            ["\x1b[5~", () => this.host.scrollByPage(-1)],
+            ["\x1b[6~", () => this.host.scrollByPage(1)],
+            ["\x1b[A", () => this.handleArrowUp()],
+            ["\x1b[B", () => this.handleArrowDown()],
+            ["\x1b[C", () => this.handleArrowRight()],
+            ["\x1b[D", () => this.handleArrowLeft()],
+            ["\x1b[1;2A", () => { this.host.inputEditor.moveUpExtend(); this.host.render(); }],
+            ["\x1b[1;2B", () => { this.host.inputEditor.moveDownExtend(); this.host.render(); }],
+            ["\x1b[1;2C", () => { this.host.inputEditor.moveRightExtend(); this.host.render(); }],
+            ["\x1b[1;2D", () => { this.host.inputEditor.moveLeftExtend(); this.host.render(); }],
+            ["\x1b[H", () => { this.host.inputEditor.moveToLineStart(); this.host.render(); }],
+            ["\x1b[F", () => { this.host.inputEditor.moveToLineEnd(); this.host.render(); }],
+            ["\x1b[1~", () => { this.host.inputEditor.moveToLineStart(); this.host.render(); }],
+            ["\x1b[4~", () => { this.host.inputEditor.moveToLineEnd(); this.host.render(); }],
+            ["\x1b[1;5H", () => { this.host.inputEditor.moveToStart(); this.host.render(); }],
+            ["\x1b[1;5F", () => { this.host.inputEditor.moveToEnd(); this.host.render(); }],
+            ["\x1b[3~", () => { this.host.resetRequestHistoryNavigation(); this.host.inputEditor.deleteForward(); this.host.render(); }],
+            ["\x1b[1;3D", () => { this.host.inputEditor.moveWordLeft(); this.host.render(); }],
+            ["\x1b[1;3C", () => { this.host.inputEditor.moveWordRight(); this.host.render(); }],
+            ["\x1bb", () => { this.host.inputEditor.moveWordLeft(); this.host.render(); }],
+            ["\x1bf", () => { this.host.inputEditor.moveWordRight(); this.host.render(); }],
+            ["\x1b[3;3~", () => { this.host.resetRequestHistoryNavigation(); this.host.inputEditor.deleteWordForward(); this.host.render(); }],
+            ["\x1b[200~", () => this.pasteHandler.beginBracketedPaste()],
+            ["\x1b[201~", () => this.pasteHandler.endBracketedPaste()],
+            ["\x1b[1;2H", () => { this.host.inputEditor.moveToLineStartExtend(); this.host.render(); }],
+            ["\x1b[1;2F", () => { this.host.inputEditor.moveToLineEndExtend(); this.host.render(); }],
+            ["\x1b[118;5u", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
+            ["\x1b[27;5;118~", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
+            ["\x1b[122;9u", () => this.undoInput()],
+            ["\x1b[27;9;122~", () => this.undoInput()],
+            ["\x1b[90;10u", () => this.redoInput()],
+            ["\x1b[122;10u", () => this.redoInput()],
+            ["\x1b[27;10;90~", () => this.redoInput()],
+            ["\x1b[27;10;122~", () => this.redoInput()],
+            ["\x1b[121;9u", () => this.redoInput()],
+            ["\x1b[27;9;121~", () => this.redoInput()],
+            ["\x1b[97;5u", () => { this.host.inputEditor.selectAll(); this.host.render(); }],
+            ["\x1b[107;5u", () => this.deleteCurrentInputLine()],
+        ];
+    }
+    isPendingEscapeSequence() {
+        return this.inputBuffer.length > 1 && this.getEscapeSequences().some(([sequence]) => sequence.startsWith(this.inputBuffer));
+    }
+    consumeEscapeSequence() {
+        const sequences = this.getEscapeSequences();
+        for (const [sequence, handler] of sequences) {
+            if (this.inputBuffer.startsWith(sequence)) {
+                this.inputBuffer = this.inputBuffer.slice(sequence.length);
+                handler();
+                return true;
+            }
+        }
+        if (this.inputBuffer.startsWith("\x1b") && this.inputBuffer.length < 6)
+            return false;
+        if (this.inputBuffer.startsWith("\x1b")) {
+            this.inputBuffer = this.inputBuffer.slice(1);
+            return true;
+        }
+        return false;
+    }
+    consumeCommandBackspaceSequence() {
+        if (!this.inputBuffer.startsWith("\x1b["))
+            return "none";
+        const match = /^\x1b\[(?:(?:8|127);(\d+)u|27;(\d+);(?:8|127)~)/.exec(this.inputBuffer);
+        if (match) {
+            const modifierValue = Number(match[1] ?? match[2]);
+            this.inputBuffer = this.inputBuffer.slice(match[0].length);
+            if (!hasTerminalCommandModifier(modifierValue)) {
+                this.host.resetRequestHistoryNavigation();
+                this.host.inputEditor.deleteBackward();
+                this.host.render();
+                return "consumed";
+            }
+            this.deleteCurrentInputLine();
+            return "consumed";
+        }
+        if (/^\x1b\[(?:8|127);\d*$/.test(this.inputBuffer))
+            return "pending";
+        if (this.inputBuffer.startsWith("\x1b[27;") && !this.inputBuffer.includes("~"))
+            return "pending";
+        return "none";
+    }
+    consumeCommandArrowPageSequence() {
+        if (!this.inputBuffer.startsWith("\x1b["))
+            return "none";
+        const legacyMatch = /^\x1b\[1;(\d+)([AB])/.exec(this.inputBuffer);
+        if (legacyMatch)
+            return this.consumeCommandArrowPageMatch(legacyMatch[0].length, Number(legacyMatch[1]), legacyMatch[2]);
+        const xtermMatch = /^\x1b\[27;(\d+);(65|66)~/.exec(this.inputBuffer);
+        if (xtermMatch)
+            return this.consumeCommandArrowPageMatch(xtermMatch[0].length, Number(xtermMatch[1]), xtermMatch[2] === "65" ? "A" : "B");
+        if (/^\x1b\[1;\d*$/.test(this.inputBuffer))
+            return "pending";
+        if (/^\x1b\[27;\d*(?:;\d*)?$/.test(this.inputBuffer))
+            return "pending";
+        return "none";
+    }
+    consumeCommandArrowPageMatch(length, modifierValue, arrow) {
+        if (!hasTerminalCommandModifier(modifierValue))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(length);
+        this.host.scrollByPage(arrow === "A" ? -1 : 1);
+        return "consumed";
+    }
+    consumeTerminalEditShortcutSequence() {
+        const result = parseTerminalEditShortcutSequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.length);
+        if (result.kind === "shortcut") {
+            if (result.shortcut === "undo")
+                this.undoInput();
+            else
+                this.redoInput();
+        }
+        return "consumed";
+    }
+    consumeTerminalInterruptSequence() {
+        const result = parseTerminalInterruptSequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.length);
+        void this.host.handleInterrupt();
+        return "consumed";
+    }
+    handleArrowUp() {
+        if (isNativeCommandPressed()) {
+            this.host.scrollByPage(-1);
+            return;
+        }
+        if (this.host.moveActivePopupMenuSelection(-1))
+            return;
+        if (this.host.getInput().includes("\n")) {
+            const pos = this.host.inputEditor.cursor;
+            const beforeCursor = this.host.getInput().slice(0, pos);
+            const lineIndex = beforeCursor.split("\n").length - 1;
+            if (lineIndex > 0) {
+                this.host.inputEditor.moveUp();
+                this.host.render();
+                return;
+            }
+        }
+        if (this.host.navigateRequestHistory(-1))
+            return;
+        this.host.scrollByLines(-1);
+    }
+    handleArrowDown() {
+        if (isNativeCommandPressed()) {
+            this.host.scrollByPage(1);
+            return;
+        }
+        if (this.host.moveActivePopupMenuSelection(1))
+            return;
+        if (this.host.getInput().includes("\n")) {
+            const pos = this.host.inputEditor.cursor;
+            const beforeCursor = this.host.getInput().slice(0, pos);
+            const lineIndex = beforeCursor.split("\n").length - 1;
+            const totalLines = this.host.getInput().split("\n").length;
+            if (lineIndex < totalLines - 1) {
+                this.host.inputEditor.moveDown();
+                this.host.render();
+                return;
+            }
+        }
+        if (this.host.navigateRequestHistory(1))
+            return;
+        this.host.scrollByLines(1);
+    }
+    handleArrowLeft() {
+        if (this.host.inputEditor.hasSelection) {
+            const [start] = this.orderedEditorSelection();
+            this.host.inputEditor.clearSelection();
+            this.host.inputEditor.setText(this.host.inputEditor.text, start);
+            this.host.render();
+            return;
+        }
+        if (this.host.inputEditor.cursor > 0) {
+            this.host.inputEditor.moveLeft();
+            this.host.render();
+        }
+    }
+    handleArrowRight() {
+        if (this.host.inputEditor.hasSelection) {
+            const [, end] = this.orderedEditorSelection();
+            this.host.inputEditor.clearSelection();
+            this.host.inputEditor.setText(this.host.inputEditor.text, end);
+            this.host.render();
+            return;
+        }
+        if (this.host.inputEditor.cursor < this.host.inputEditor.text.length) {
+            this.host.inputEditor.moveRight();
+            this.host.render();
+        }
+    }
+    orderedEditorSelection() {
+        const sel = this.host.inputEditor.selection;
+        if (!sel)
+            return [this.host.inputEditor.cursor, this.host.inputEditor.cursor];
+        return sel.anchor < sel.active ? [sel.anchor, sel.active] : [sel.active, sel.anchor];
+    }
+    insertInputNewline() {
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor.insert("\n");
+        this.host.render();
+    }
+    undoInput() {
+        this.host.resetRequestHistoryNavigation();
+        if (this.host.inputEditor.undo())
+            this.host.resetInputMenuDismissals();
+        this.host.render();
+    }
+    redoInput() {
+        this.host.resetRequestHistoryNavigation();
+        if (this.host.inputEditor.redo())
+            this.host.resetInputMenuDismissals();
+        this.host.render();
+    }
+    handleEditShortcutChar(char) {
+        const controlShortcut = terminalEditShortcutForControlChar(char, this.isShiftPressed());
+        if (controlShortcut) {
+            if (controlShortcut === "undo")
+                this.undoInput();
+            else
+                this.redoInput();
+            return true;
+        }
+        if (!isNativeCommandPressed())
+            return false;
+        const lower = char.toLowerCase();
+        if (lower === "z") {
+            if (char === "Z" || this.isShiftPressed())
+                this.redoInput();
+            else
+                this.undoInput();
+            return true;
+        }
+        if (lower === "y") {
+            this.redoInput();
+            return true;
+        }
+        return false;
+    }
+    deleteCurrentInputLine() {
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor.deleteToLineStartOrPreviousLineEnd();
+        this.host.render();
+    }
+    handleChar(char) {
+        if (char === "\u0003") {
+            void this.host.handleInterrupt();
+            return;
+        }
+        if (char === "\x1b") {
+            void this.host.handleEscape();
+            return;
+        }
+        if (char === "\t") {
+            if (this.host.getDirectPopupMenu() === "sdk-menu")
+                return;
+            if (this.host.autocompleteModel())
+                return;
+            if (this.host.autocompleteThinking())
+                return;
+            this.host.autocompleteSlashCommand();
+            return;
+        }
+        if (!this.host.inputEditor.isInBracketedPaste && this.handleEditShortcutChar(char))
+            return;
+        if (this.host.handleDirectPopupInput(char))
+            return;
+        if (char === "\u0004" && this.host.getInput().length === 0) {
+            void this.host.stop();
+            return;
+        }
+        if (char === "\u000c") {
+            this.host.render();
+            return;
+        }
+        if (char === "\u0007") {
+            this.host.toggleVoiceRecording();
+            return;
+        }
+        if (char === "\r" || char === "\n") {
+            if (this.host.inputEditor.isInBracketedPaste) {
+                this.pasteHandler.appendBracketedPasteText("\n");
+                return;
+            }
+            if (this.isShiftPressed()) {
+                this.insertInputNewline();
+                return;
+            }
+            this.host.handleEnter();
+            return;
+        }
+        if (char === "\u0015" || ((char === "\u007f" || char === "\b") && isNativeCommandPressed())) {
+            this.deleteCurrentInputLine();
+            return;
+        }
+        if (char === "\x16") {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return;
+        }
+        if (char === "\u007f" || char === "\b") {
+            if (this.host.inputEditor.isInBracketedPaste)
+                return;
+            this.host.resetRequestHistoryNavigation();
+            this.host.inputEditor.deleteBackward();
+            this.host.render();
+            return;
+        }
+        if (char >= " ") {
+            if (this.host.inputEditor.isInBracketedPaste) {
+                this.pasteHandler.appendBracketedPasteText(char);
+            }
+            else {
+                this.host.resetRequestHistoryNavigation();
+                this.host.inputEditor.insert(char);
+            }
+            this.host.render();
+        }
+    }
+    isShiftPressed() {
+        return this.host.isShiftPressed?.() ?? isNativeShiftPressed();
+    }
+}

package/dist/app/input-paste-handler.d.ts

@@ -0,0 +1,27 @@
+import { InputEditor } from "../input-editor.js";
+export type InputPasteHost = {
+    readonly inputEditor: InputEditor;
+    readonly cwd: string;
+    resetRequestHistoryNavigation(): void;
+    render(): void;
+};
+export declare class InputPasteHandler {
+    private readonly host;
+    private pasteBuffer;
+    private readonly recentPasteFingerprints;
+    private suppressImagePathPasteUntil;
+    constructor(host: InputPasteHost);
+    handlePlainData(data: string): boolean;
+    beginBracketedPaste(): void;
+    appendBracketedPasteText(text: string): void;
+    endBracketedPaste(): void;
+    handleClipboardImagePaste(): Promise<void>;
+    private isPlainMultilinePasteChunk;
+    private plainPasteFilePath;
+    private isDuplicatePaste;
+    private handlePasteEnd;
+    private handleFilePaste;
+    private filePathForInput;
+    private displayPathForInput;
+    private insertPastedPathText;
+}

package/dist/app/input-paste-handler.js

@@ -0,0 +1,146 @@
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { isImagePath, looksLikeFilePath, quoteFilePathForInput, readClipboardImage } from "../input-editor.js";
+import { PASTE_DUPLICATE_WINDOW_MS } from "./constants.js";
+import { normalizePastedTextForDuplicateKey } from "./render-text.js";
+export class InputPasteHandler {
+    host;
+    pasteBuffer = "";
+    recentPasteFingerprints = new Map();
+    suppressImagePathPasteUntil = 0;
+    constructor(host) {
+        this.host = host;
+    }
+    handlePlainData(data) {
+        const plainFilePath = !this.host.inputEditor.isInBracketedPaste && this.plainPasteFilePath(data);
+        if (plainFilePath) {
+            if (isImagePath(plainFilePath) && Date.now() < this.suppressImagePathPasteUntil) {
+                this.host.render();
+                return true;
+            }
+            void this.handleFilePaste(plainFilePath);
+            return true;
+        }
+        if (!this.host.inputEditor.isInBracketedPaste && this.isPlainMultilinePasteChunk(data)) {
+            if (this.isDuplicatePaste("text", data)) {
+                this.host.render();
+                return true;
+            }
+            this.host.resetRequestHistoryNavigation();
+            this.host.inputEditor.attachPastedText(data);
+            this.host.render();
+            return true;
+        }
+        return false;
+    }
+    beginBracketedPaste() {
+        this.host.inputEditor.beginBracketedPaste();
+        this.pasteBuffer = "";
+    }
+    appendBracketedPasteText(text) {
+        this.pasteBuffer += text;
+    }
+    endBracketedPaste() {
+        this.host.inputEditor.endBracketedPaste();
+        this.handlePasteEnd();
+    }
+    async handleClipboardImagePaste() {
+        const image = await readClipboardImage();
+        if (!image)
+            return;
+        if (this.isDuplicatePaste(`image:${image.mimeType}`, image.data)) {
+            this.host.render();
+            return;
+        }
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor.attachImage(image.data, image.mimeType);
+        this.suppressImagePathPasteUntil = Date.now() + 1000;
+        this.host.render();
+    }
+    isPlainMultilinePasteChunk(data) {
+        if (data.length <= 1)
+            return false;
+        if (data.includes("\x1b"))
+            return false;
+        if (!data.includes("\n") && !data.includes("\r"))
+            return false;
+        return true;
+    }
+    plainPasteFilePath(data) {
+        if (data.length <= 1)
+            return null;
+        if (data.includes("\x1b"))
+            return null;
+        if (data.includes("\n") || data.includes("\r"))
+            return null;
+        return looksLikeFilePath(data);
+    }
+    isDuplicatePaste(kind, payload) {
+        const now = Date.now();
+        for (const [fingerprint, timestamp] of this.recentPasteFingerprints) {
+            if (now - timestamp > PASTE_DUPLICATE_WINDOW_MS)
+                this.recentPasteFingerprints.delete(fingerprint);
+        }
+        const normalizedPayload = kind === "text" ? normalizePastedTextForDuplicateKey(payload) : payload;
+        const fingerprint = `${kind}:${createHash("sha256").update(normalizedPayload).digest("hex")}`;
+        const previousTimestamp = this.recentPasteFingerprints.get(fingerprint);
+        if (previousTimestamp !== undefined && now - previousTimestamp <= PASTE_DUPLICATE_WINDOW_MS)
+            return true;
+        this.recentPasteFingerprints.set(fingerprint, now);
+        return false;
+    }
+    handlePasteEnd() {
+        const text = this.pasteBuffer;
+        this.pasteBuffer = "";
+        if (!text)
+            return;
+        const filePath = this.plainPasteFilePath(text);
+        if (filePath) {
+            if (isImagePath(filePath) && Date.now() < this.suppressImagePathPasteUntil) {
+                this.host.render();
+                return;
+            }
+            void this.handleFilePaste(filePath);
+            return;
+        }
+        if (this.isDuplicatePaste("text", text)) {
+            this.host.render();
+            return;
+        }
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor.attachPastedText(text);
+        this.host.render();
+    }
+    async handleFilePaste(filePath) {
+        const inputPath = await this.filePathForInput(filePath);
+        this.insertPastedPathText(inputPath);
+        this.host.render();
+    }
+    async filePathForInput(filePath) {
+        const resolved = resolve(this.host.cwd, filePath);
+        try {
+            const s = await stat(resolved);
+            if (s.isFile())
+                return this.displayPathForInput(resolved);
+        }
+        catch {
+            // The terminal can still paste a file-looking path before the file is
+            // visible to us. Insert the path text instead of trying to attach content.
+        }
+        return this.displayPathForInput(resolved);
+    }
+    displayPathForInput(resolvedPath) {
+        const cwd = resolve(this.host.cwd);
+        const rel = relative(cwd, resolvedPath);
+        if (rel && !rel.startsWith("..") && !isAbsolute(rel))
+            return rel;
+        return resolvedPath;
+    }
+    insertPastedPathText(filePath) {
+        if (this.isDuplicatePaste("text", filePath))
+            return;
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor.insert(quoteFilePathForInput(filePath));
+    }
+}

package/dist/app/menu-items-controller.d.ts

@@ -0,0 +1,32 @@
+import type { AgentSessionRuntime, SessionInfo } from "@earendil-works/pi-coding-agent";
+import type { PopupMenuItem } from "../ui.js";
+import type { Entry, ModelMenuValue, QueueMessageMenuValue, ResumeMenuValue, ScopedSessionModel, SessionModel, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "./types.js";
+export type AppMenuItemsControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    getBuiltinSlashCommands(): readonly SlashCommand[];
+    getEntries(): readonly Entry[];
+    getResumeSessions(): readonly SessionInfo[];
+};
+export declare class AppMenuItemsController {
+    private readonly host;
+    private resumeMenuLoaderCache;
+    constructor(host: AppMenuItemsControllerHost);
+    parseSlashInput(text: string): import("./types.js").ParsedSlashInput | undefined;
+    getResourceSlashCommands(): SlashCommand[];
+    getSlashCommandMatches(query: string, limit?: number): import("../fuzzy.js").FuzzyMatch<SlashCommand>[];
+    getSlashCommandMenuItems(query: string): PopupMenuItem<SlashCommand>[];
+    modelRef(model: SessionModel): string;
+    getFavoriteScopedModels(): ScopedSessionModel[];
+    getModelMenuItems(query: string): PopupMenuItem<ModelMenuValue>[];
+    getThinkingMenuItems(query: string): PopupMenuItem<ThinkingMenuValue>[];
+    getUserMessageMenuItems(): PopupMenuItem<UserMessageMenuValue>[];
+    getUserMessageJumpMenuItems(query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
+    getQueueMessageMenuItems(): PopupMenuItem<QueueMessageMenuValue>[];
+    getResumeMenuItems(query: string, limit?: number): PopupMenuItem<ResumeMenuValue>[];
+    private getResumeMenuItemsLoader;
+    private getAllSlashCommands;
+    private isCurrentModel;
+    private resolveScopedModelRefs;
+    private getModelMenuModels;
+    private thinkingLevelDescription;
+}