feat: drag and drop file paths into terminal (wavetermdev#2857)

Fixes wavetermdev#746, fixes wavetermdev#2813

Drag a file from Finder into a terminal and it pastes the quoted path.
Uses `webUtils.getPathForFile()` through a preload bridge since Electron
32 killed `File.path`. Handles spaces in filenames.

Needs app restart after install (preload change).

Author: JustHereToHelp

emain/preload.ts

@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { contextBridge, ipcRenderer, Rectangle, WebviewTag } from "electron";
+import { contextBridge, ipcRenderer, Rectangle, webUtils, WebviewTag } from "electron";
 
 // update type in custom.d.ts (ElectronApi type)
 contextBridge.exposeInMainWorld("api", {
@@ -66,6 +66,7 @@ contextBridge.exposeInMainWorld("api", {
     incrementTermCommands: () => ipcRenderer.send("increment-term-commands"),
     nativePaste: () => ipcRenderer.send("native-paste"),
     doRefresh: () => ipcRenderer.send("do-refresh"),
+    getPathForFile: (file: File): string => webUtils.getPathForFile(file),
     showOpenDialog: (options: {
         title?: string;
         defaultPath?: string;

frontend/app/view/term/termutil.ts

@@ -1,6 +1,8 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+import * as TermTypes from "@xterm/xterm";
+
 export const DefaultTermTheme = "default-dark";
 export const DefaultLightTermTheme = "light-default";
 import { getResolvedTheme } from "@/app/hook/usetheme";
@@ -141,9 +143,8 @@ export async function extractClipboardData(item: ClipboardItem): Promise<GenClip
         if (!html) {
             return null;
         }
-        const tempDiv = document.createElement("div");
-        tempDiv.innerHTML = html;
-        const text = tempDiv.textContent || "";
+        const doc = new DOMParser().parseFromString(html, "text/html");
+        const text = doc.body.textContent || "";
         return text ? { text } : null;
     }
 
@@ -269,9 +270,8 @@ export async function extractDataTransferItems(items: DataTransferItemList): Pro
                     resolve([]);
                     return;
                 }
-                const tempDiv = document.createElement("div");
-                tempDiv.innerHTML = html;
-                const text = tempDiv.textContent || "";
+                const doc = new DOMParser().parseFromString(html, "text/html");
+                const text = doc.body.textContent || "";
                 resolve(text ? [{ text }] : []);
             });
         });
@@ -327,3 +327,70 @@ export async function extractAllClipboardData(e?: ClipboardEvent): Promise<Array
         return results;
     }
 }
+
+
+/**
+ * Converts terminal buffer lines to text, properly handling wrapped lines.
+ * Wrapped lines (long lines split across multiple buffer rows) are concatenated
+ * without adding newlines between them, while preserving actual line breaks.
+ *
+ * @param buffer - The xterm.js buffer to extract lines from
+ * @param startIndex - Starting buffer index (inclusive, 0-based)
+ * @param endIndex - Ending buffer index (exclusive, 0-based)
+ * @returns Array of logical lines (with wrapped lines concatenated)
+ */
+export function bufferLinesToText(buffer: TermTypes.IBuffer, startIndex: number, endIndex: number): string[] {
+    const lines: string[] = [];
+    let currentLine = "";
+    let isFirstLine = true;
+
+    // Clamp indices to valid buffer range to avoid out-of-bounds access on the
+    // underlying circular buffer, which could return stale/wrong data.
+    const clampedStart = Math.max(0, Math.min(startIndex, buffer.length));
+    const clampedEnd = Math.max(0, Math.min(endIndex, buffer.length));
+
+    for (let i = clampedStart; i < clampedEnd; i++) {
+        const line = buffer.getLine(i);
+        if (line) {
+            const lineText = line.translateToString(true);
+            // If this line is wrapped (continuation of previous line), concatenate without newline
+            if (line.isWrapped && !isFirstLine) {
+                currentLine += lineText;
+            } else {
+                // This is a new logical line
+                if (!isFirstLine) {
+                    lines.push(currentLine);
+                }
+                currentLine = lineText;
+                isFirstLine = false;
+            }
+        }
+    }
+
+    // Don't forget the last line
+    if (!isFirstLine) {
+        lines.push(currentLine);
+    }
+
+    // Trim trailing blank lines only when the requested range extends to the
+    // actual end of the buffer.  A terminal allocates a fixed number of rows
+    // (e.g. 80) but only the first few may contain real content; the rest are
+    // empty placeholder rows.  We strip those so callers don't receive a wall
+    // of empty strings.
+    //
+    // Crucially, if the caller requested a specific sub-range (e.g. lines
+    // 100-150) and lines 140-150 happen to be blank, those blanks are
+    // intentional and must NOT be removed.  We only trim when the range
+    // reaches the very end of the buffer.
+    if (clampedEnd >= buffer.length) {
+        while (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+    }
+
+    return lines;
+}
+
+export function quoteForPosixShell(filePath: string): string {
+    return "'" + filePath.replace(/'/g, "'\\''") + "'";
+}

frontend/app/view/term/termwrap.ts

@@ -4,6 +4,7 @@ import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
 import {
     atoms,
+    getApi,
     getOverrideConfigAtom,
     getSettingsKeyAtom,
     globalStore,
@@ -28,7 +29,7 @@ import { FitAddon } from "./fitaddon";
 import { ROLLING_INTERVAL_MS } from "./sessionhistory-capture";
 import { ObjectService } from "@/app/store/services";
 import { windowsToWslPath } from "@/util/pathutil";
-import { createTempFileFromBlob, extractAllClipboardData } from "./termutil";
+import { createTempFileFromBlob, extractAllClipboardData, quoteForPosixShell } from "./termutil";
 import {
     loadInitialTerminalData,
     runProcessIdleTimeout,
@@ -269,6 +270,38 @@ export class TermWrap {
             const ligaturesAddon = new LigaturesAddon();
             this.terminal.loadAddon(ligaturesAddon);
         }
+
+        const dragoverHandler = (e: DragEvent) => {
+            e.preventDefault();
+            if (e.dataTransfer) {
+                e.dataTransfer.dropEffect = "copy";
+            }
+        };
+        const dropHandler = (e: DragEvent) => {
+            e.preventDefault();
+            if (!e.dataTransfer || e.dataTransfer.files.length === 0) {
+                return;
+            }
+            const paths: string[] = [];
+            for (let i = 0; i < e.dataTransfer.files.length; i++) {
+                const file = e.dataTransfer.files[i];
+                const filePath = getApi().getPathForFile(file);
+                if (filePath) {
+                    paths.push(quoteForPosixShell(filePath));
+                }
+            }
+            if (paths.length > 0) {
+                this.terminal.paste(paths.join(" ") + " ");
+            }
+        };
+        this.connectElem.addEventListener("dragover", dragoverHandler);
+        this.connectElem.addEventListener("drop", dropHandler);
+        this.toDispose.push({
+            dispose: () => {
+                this.connectElem.removeEventListener("dragover", dragoverHandler);
+                this.connectElem.removeEventListener("drop", dropHandler);
+            },
+        });
         this.handleResize();
         const pasteHandler = this.pasteHandler.bind(this);
         this.connectElem.addEventListener("paste", pasteHandler, true);

frontend/types/custom.d.ts

@@ -131,6 +131,52 @@ declare global {
             eventType: "did-navigate" | "did-navigate-in-page" | "will-navigate",
             isMainFrame?: boolean
         ) => void;
+        getZoomFactor: () => number; // get-zoom-factor
+        showWorkspaceAppMenu: (workspaceId: string) => void; // workspace-appmenu-show
+        showBuilderAppMenu: (builderId: string) => void; // builder-appmenu-show
+        showContextMenu: (workspaceId: string, menu: ElectronContextMenuItem[]) => void; // contextmenu-show
+        onContextMenuClick: (callback: (id: string | null) => void) => void; // contextmenu-click
+        onNavigate: (callback: (url: string) => void) => void;
+        onIframeNavigate: (callback: (url: string) => void) => void;
+        downloadFile: (path: string) => void; // download
+        openExternal: (url: string) => void; // open-external
+        onFullScreenChange: (callback: (isFullScreen: boolean) => void) => void; // fullscreen-change
+        onZoomFactorChange: (callback: (zoomFactor: number) => void) => void; // zoom-factor-change
+        onUpdaterStatusChange: (callback: (status: UpdaterStatus) => void) => void; // app-update-status
+        getUpdaterStatus: () => UpdaterStatus; // get-app-update-status
+        getUpdaterChannel: () => string; // get-updater-channel
+        installAppUpdate: () => void; // install-app-update
+        onMenuItemAbout: (callback: () => void) => void; // menu-item-about
+        updateWindowControlsOverlay: (rect: Dimensions) => void; // update-window-controls-overlay
+        onReinjectKey: (callback: (waveEvent: WaveKeyboardEvent) => void) => void; // reinject-key
+        setWebviewFocus: (focusedId: number) => void; // webview-focus, focusedId is the getWebContentsId of the webview
+        registerGlobalWebviewKeys: (keys: string[]) => void; // register-global-webview-keys
+        onControlShiftStateUpdate: (callback: (state: boolean) => void) => void; // control-shift-state-update
+        createWorkspace: () => void; // create-workspace
+        switchWorkspace: (workspaceId: string) => void; // switch-workspace
+        deleteWorkspace: (workspaceId: string) => void; // delete-workspace
+        setActiveTab: (tabId: string) => void; // set-active-tab
+        createTab: () => void; // create-tab
+        closeTab: (workspaceId: string, tabId: string, confirmClose: boolean) => Promise<boolean>; // close-tab
+        setWindowInitStatus: (status: "ready" | "wave-ready") => void; // set-window-init-status
+        onWaveInit: (callback: (initOpts: WaveInitOpts) => void) => void; // wave-init
+        onBuilderInit: (callback: (initOpts: BuilderInitOpts) => void) => void; // builder-init
+        sendLog: (log: string) => void; // fe-log
+        onQuicklook: (filePath: string) => void; // quicklook
+        openNativePath(filePath: string): void; // open-native-path
+        captureScreenshot(rect: Electron.Rectangle): Promise<string>; // capture-screenshot
+        setKeyboardChordMode: () => void; // set-keyboard-chord-mode
+        clearWebviewStorage: (webContentsId: number) => Promise<void>; // clear-webview-storage
+        setWaveAIOpen: (isOpen: boolean) => void; // set-waveai-open
+        closeBuilderWindow: () => void; // close-builder-window
+        incrementTermCommands: (opts?: { isRemote?: boolean; isWsl?: boolean; isDurable?: boolean }) => void; // increment-term-commands
+        nativePaste: () => void; // native-paste
+        openBuilder: (appId?: string) => void; // open-builder
+        setBuilderWindowAppId: (appId: string) => void; // set-builder-window-appid
+        doRefresh: () => void; // do-refresh
+        getPathForFile: (file: File) => string; // webUtils.getPathForFile
+        saveTextFile: (fileName: string, content: string) => Promise<boolean>; // save-text-file
+        setIsActive: () => Promise<void>; // set-is-active
     };
 
     type ElectronContextMenuItem = {