pasting images fix

arul28 · arul28 · commit 812254be4708 · 2026-05-03T11:25:14.000-04:00
diff --git a/apps/desktop/scripts/dev.cjs b/apps/desktop/scripts/dev.cjs
@@ -260,10 +260,12 @@ async function main() {
   const electronEnv = { VITE_DEV_SERVER_URL: devServerUrl };
   const launchElectron = () => {
     const electronArgs = ["electron", `--remote-debugging-port=${remoteDebugPort}`];
+    // Electron treats the first non-switch argument as the app path. Keep "."
+    // before paired macOS process flags so their value is not parsed as the app.
+    electronArgs.push(".");
     if (process.platform === "darwin") {
       electronArgs.push("-ApplePersistenceIgnoreState", "YES");
     }
-    electronArgs.push(".");
     const child = spawnProcess("electron", npxCommand, electronArgs, electronEnv);
     electron = child;
     children.add(child);
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -2717,6 +2717,10 @@ export function registerIpc({
     clipboard.writeText(text);
   });
 
+  ipcMain.handle(IPC.appHasClipboardImage, async (): Promise<boolean> => {
+    return !clipboard.readImage().isEmpty();
+  });
+
   ipcMain.handle(IPC.appReadClipboardImage, async (): Promise<{ data: string; filename: string; mimeType: string } | null> => {
     const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
     const image = clipboard.readImage();
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
@@ -683,6 +683,7 @@ declare global {
         revealPath: (path: string) => Promise<void>;
         openPath: (path: string) => Promise<void>;
         writeClipboardText: (text: string) => Promise<void>;
+        hasClipboardImage: () => Promise<boolean>;
         readClipboardImage: () => Promise<{ data: string; filename: string; mimeType: string } | null>;
         getImageDataUrl: (path: string) => Promise<{ dataUrl: string }>;
         writeClipboardImage: (path: string) => Promise<void>;
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
@@ -1021,6 +1021,8 @@ contextBridge.exposeInMainWorld("ade", {
       ipcRenderer.invoke(IPC.appOpenPath, { path }),
     writeClipboardText: async (text: string): Promise<void> =>
       ipcRenderer.invoke(IPC.appWriteClipboardText, { text }),
+    hasClipboardImage: async (): Promise<boolean> =>
+      ipcRenderer.invoke(IPC.appHasClipboardImage),
     readClipboardImage: async (): Promise<{ data: string; filename: string; mimeType: string } | null> =>
       ipcRenderer.invoke(IPC.appReadClipboardImage),
     getImageDataUrl: async (path: string): Promise<{ dataUrl: string }> =>
diff --git a/apps/desktop/src/renderer/browserMock.ts b/apps/desktop/src/renderer/browserMock.ts
@@ -2638,6 +2638,7 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
       openExternal: resolvedArg(undefined),
       revealPath: resolvedArg(undefined),
       writeClipboardText: resolvedArg(undefined),
+      hasClipboardImage: resolved(false),
       readClipboardImage: resolved(null),
       getImageDataUrl: resolvedArg({ dataUrl: "" }),
       writeClipboardImage: resolvedArg(undefined),
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
@@ -151,6 +151,9 @@ import { WORK_SURFACE_REVEALED_EVENT } from "./workSurfaceVisibility";
 
 function installWindowAde() {
   (window as any).ade = {
+    app: {
+      hasClipboardImage: vi.fn().mockResolvedValue(false),
+    },
     pty: {
       resize: vi.fn().mockResolvedValue(undefined),
       write: vi.fn().mockResolvedValue(undefined),
@@ -185,6 +188,27 @@ async function flushAnimationFrame() {
   });
 }
 
+async function flushPromises() {
+  await act(async () => {
+    await Promise.resolve();
+  });
+}
+
+function createPasteEvent(text: string): Event {
+  const event = new Event("paste", { bubbles: true, cancelable: true });
+  Object.defineProperty(event, "clipboardData", {
+    configurable: true,
+    value: {
+      files: [],
+      items: [],
+      getData: vi.fn((type: string) => (
+        type === "text/plain" || type === "text" ? text : ""
+      )),
+    },
+  });
+  return event;
+}
+
 function triggerResizeObserver() {
   const latest = resizeObservers.at(-1);
   if (!latest) throw new Error("ResizeObserver not installed");
@@ -525,6 +549,162 @@ describe("TerminalView", () => {
     expect(terminal?.options.scrollback).toBe(20_000);
   });
 
+  it("writes text paste contents directly to the PTY", async () => {
+    render(<TerminalView ptyId="pty-text-paste" sessionId="session-text-paste" isActive />);
+    await flushAllTimers();
+
+    const terminal = mockState.terminalInstances.at(-1) as {
+      element: HTMLElement | null;
+    } | undefined;
+    expect(terminal?.element).toBeTruthy();
+
+    const ptyWrite = window.ade.pty.write as unknown as ReturnType<typeof vi.fn>;
+    const hasClipboardImage = window.ade.app.hasClipboardImage as unknown as ReturnType<typeof vi.fn>;
+    ptyWrite.mockClear();
+    hasClipboardImage.mockClear();
+
+    const event = createPasteEvent("hello from clipboard");
+    terminal!.element!.dispatchEvent(event);
+
+    expect(event.defaultPrevented).toBe(true);
+    expect(ptyWrite).toHaveBeenCalledWith({
+      ptyId: "pty-text-paste",
+      data: "hello from clipboard",
+    });
+    expect(hasClipboardImage).not.toHaveBeenCalled();
+  });
+
+  it("maps macOS Cmd+V with an image-only clipboard to Ctrl+V terminal input", async () => {
+    const platformDescriptor = Object.getOwnPropertyDescriptor(window.navigator, "platform");
+    const originalPlatform = window.navigator.platform;
+    try {
+      Object.defineProperty(window.navigator, "platform", {
+        configurable: true,
+        value: "MacIntel",
+      });
+      (window.ade.app.hasClipboardImage as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(true);
+
+      render(<TerminalView ptyId="pty-image-paste" sessionId="session-image-paste" isActive />);
+      await flushAllTimers();
+
+      const terminal = mockState.terminalInstances.at(-1) as {
+        attachCustomKeyEventHandler: ReturnType<typeof vi.fn>;
+        element: HTMLElement | null;
+      } | undefined;
+      expect(terminal?.element).toBeTruthy();
+      const keyHandler = terminal?.attachCustomKeyEventHandler.mock.calls.at(-1)?.[0] as ((ev: KeyboardEvent) => boolean) | undefined;
+      expect(keyHandler).toBeTruthy();
+
+      const ptyWrite = window.ade.pty.write as unknown as ReturnType<typeof vi.fn>;
+      ptyWrite.mockClear();
+
+      const handled = keyHandler!({
+        type: "keydown",
+        key: "v",
+        metaKey: true,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+        preventDefault: vi.fn(),
+      } as unknown as KeyboardEvent);
+      expect(handled).toBe(false);
+
+      const event = createPasteEvent("");
+      terminal!.element!.dispatchEvent(event);
+      await flushPromises();
+
+      expect(event.defaultPrevented).toBe(true);
+      expect(window.ade.app.hasClipboardImage).toHaveBeenCalledTimes(1);
+      expect(ptyWrite).toHaveBeenCalledWith({
+        ptyId: "pty-image-paste",
+        data: "\x16",
+      });
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(130);
+      });
+      expect(ptyWrite).toHaveBeenCalledTimes(1);
+    } finally {
+      if (platformDescriptor) {
+        Object.defineProperty(window.navigator, "platform", platformDescriptor);
+      } else {
+        Object.defineProperty(window.navigator, "platform", {
+          configurable: true,
+          value: originalPlatform,
+        });
+      }
+    }
+  });
+
+  it("falls back to native image paste when macOS Cmd+V does not fire a paste event", async () => {
+    const platformDescriptor = Object.getOwnPropertyDescriptor(window.navigator, "platform");
+    const clipboardDescriptor = Object.getOwnPropertyDescriptor(window.navigator, "clipboard");
+    const originalPlatform = window.navigator.platform;
+    try {
+      Object.defineProperty(window.navigator, "platform", {
+        configurable: true,
+        value: "MacIntel",
+      });
+      Object.defineProperty(window.navigator, "clipboard", {
+        configurable: true,
+        value: {
+          readText: vi.fn().mockResolvedValue(""),
+          writeText: vi.fn().mockResolvedValue(undefined),
+        },
+      });
+      (window.ade.app.hasClipboardImage as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(true);
+
+      render(<TerminalView ptyId="pty-image-fallback" sessionId="session-image-fallback" isActive />);
+      await flushAllTimers();
+
+      const terminal = mockState.terminalInstances.at(-1) as {
+        attachCustomKeyEventHandler: ReturnType<typeof vi.fn>;
+      } | undefined;
+      const keyHandler = terminal?.attachCustomKeyEventHandler.mock.calls.at(-1)?.[0] as ((ev: KeyboardEvent) => boolean) | undefined;
+      expect(keyHandler).toBeTruthy();
+
+      const ptyWrite = window.ade.pty.write as unknown as ReturnType<typeof vi.fn>;
+      ptyWrite.mockClear();
+
+      const handled = keyHandler!({
+        type: "keydown",
+        key: "v",
+        metaKey: true,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+        preventDefault: vi.fn(),
+      } as unknown as KeyboardEvent);
+      expect(handled).toBe(false);
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(130);
+      });
+      await flushPromises();
+
+      expect(window.navigator.clipboard.readText).toHaveBeenCalledTimes(1);
+      expect(window.ade.app.hasClipboardImage).toHaveBeenCalledTimes(1);
+      expect(ptyWrite).toHaveBeenCalledWith({
+        ptyId: "pty-image-fallback",
+        data: "\x16",
+      });
+    } finally {
+      if (platformDescriptor) {
+        Object.defineProperty(window.navigator, "platform", platformDescriptor);
+      } else {
+        Object.defineProperty(window.navigator, "platform", {
+          configurable: true,
+          value: originalPlatform,
+        });
+      }
+      if (clipboardDescriptor) {
+        Object.defineProperty(window.navigator, "clipboard", clipboardDescriptor);
+      } else {
+        Reflect.deleteProperty(window.navigator, "clipboard");
+      }
+    }
+  });
+
   it("keeps live parked runtimes available so switching away does not discard TUI state", async () => {
     const view = render(<TerminalView ptyId="pty-live" sessionId="session-live" isActive />);
     await flushAllTimers();
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
@@ -96,6 +96,7 @@ const MIN_HOST_HEIGHT_PX = 48;
 const INVALID_FIT_RETRY_MS = 90;
 const RENDERER_RESET_COOLDOWN_MS = 250;
 const TERMINAL_RENDERER_STORAGE_KEY = "ade.terminalRenderer";
+const TERMINAL_CTRL_V = "\x16";
 const runtimeCache = new Map<string, CachedRuntime>();
 let parkedRoot: HTMLDivElement | null = null;
 
@@ -360,6 +361,23 @@ function setRuntimeVisibilityState(runtime: CachedRuntime, visible: boolean) {
   runtime.visible = visible;
 }
 
+function writePtyInput(runtime: CachedRuntime, data: string) {
+  if (!data || runtime.disposed) return;
+  window.ade.pty.write({ ptyId: runtime.ptyId, data }).catch(() => {});
+}
+
+async function pasteNativeClipboardImageShortcut(runtime: CachedRuntime): Promise<boolean> {
+  if (runtime.disposed) return false;
+  try {
+    const hasImage = await window.ade.app.hasClipboardImage();
+    if (!hasImage || runtime.disposed) return false;
+    writePtyInput(runtime, TERMINAL_CTRL_V);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function teardownRuntime(runtime: CachedRuntime) {
   runtime.disposed = true;
   clearDisposeTimer(runtime);
@@ -875,8 +893,10 @@ function createRuntime(args: {
     lastPasteEventAt = Date.now();
     const text = ev.clipboardData?.getData("text/plain") ?? ev.clipboardData?.getData("text");
     if (text && !runtime.disposed) {
-      window.ade.pty.write({ ptyId: runtime.ptyId, data: text }).catch(() => {});
+      writePtyInput(runtime, text);
+      return;
     }
+    void pasteNativeClipboardImageShortcut(runtime);
   }, true);
 
   term.attachCustomKeyEventHandler((ev) => {
@@ -896,11 +916,20 @@ function createRuntime(args: {
       const before = lastPasteEventAt;
       setTimeout(() => {
         if (lastPasteEventAt !== before || runtime.disposed) return;
-        navigator.clipboard.readText().then((text) => {
+        const readText = navigator.clipboard?.readText;
+        if (typeof readText !== "function") {
+          void pasteNativeClipboardImageShortcut(runtime);
+          return;
+        }
+        readText.call(navigator.clipboard).then((text) => {
           if (text && !runtime.disposed) {
-            window.ade.pty.write({ ptyId: runtime.ptyId, data: text }).catch(() => {});
+            writePtyInput(runtime, text);
+            return;
           }
-        }).catch(() => {});
+          void pasteNativeClipboardImageShortcut(runtime);
+        }).catch(() => {
+          void pasteNativeClipboardImageShortcut(runtime);
+        });
       }, 120);
       return false;
     }
@@ -917,27 +946,27 @@ function createRuntime(args: {
     // Shift+Enter should insert a newline in tools like Claude/Codex prompts.
     if (ev.shiftKey && ev.key === "Enter") {
       ev.preventDefault();
-      window.ade.pty.write({ ptyId: runtime.ptyId, data: "\n" }).catch(() => {});
+      writePtyInput(runtime, "\n");
       return false;
     }
 
     if (isMac && ev.altKey && ev.key === "Backspace") {
       ev.preventDefault();
-      window.ade.pty.write({ ptyId: runtime.ptyId, data: "\x1b\x7f" }).catch(() => {});
+      writePtyInput(runtime, "\x1b\x7f");
       return false;
     }
 
     if (isMac && ev.metaKey && ev.key === "Backspace") {
       ev.preventDefault();
       // Ctrl+U: kill to beginning of line
-      window.ade.pty.write({ ptyId: runtime.ptyId, data: "\x15" }).catch(() => {});
+      writePtyInput(runtime, "\x15");
       return false;
     }
 
     // Ctrl+Backspace: delete word backward (same as Ctrl+W)
     if (ev.ctrlKey && ev.key === "Backspace") {
       ev.preventDefault();
-      window.ade.pty.write({ ptyId: runtime.ptyId, data: "\x17" }).catch(() => {});
+      writePtyInput(runtime, "\x17");
       return false;
     }
 
@@ -958,7 +987,7 @@ function createRuntime(args: {
         const merged = inputBuf.join("");
         inputBuf = [];
         if (merged && !runtime.disposed) {
-          window.ade.pty.write({ ptyId: runtime.ptyId, data: merged }).catch(() => {});
+          writePtyInput(runtime, merged);
         }
       });
     }
diff --git a/apps/desktop/src/shared/ipc.ts b/apps/desktop/src/shared/ipc.ts
@@ -7,6 +7,7 @@ export const IPC = {
   appRevealPath: "ade.app.revealPath",
   appOpenPath: "ade.app.openPath",
   appWriteClipboardText: "ade.app.writeClipboardText",
+  appHasClipboardImage: "ade.app.hasClipboardImage",
   appReadClipboardImage: "ade.app.readClipboardImage",
   appGetImageDataUrl: "ade.app.getImageDataUrl",
   appWriteClipboardImage: "ade.app.writeClipboardImage",
