feat(composer): drop non-image files as filesystem paths

apps/desktop/src/preload.ts

@@ -5,7 +5,7 @@ import type {
   DesktopPreviewTabState,
 } from "@t3tools/contracts";
 import { exposeClerkBridge } from "@clerk/electron/preload";
-import { contextBridge, ipcRenderer } from "electron";
+import { contextBridge, ipcRenderer, webUtils } from "electron";
 
 import * as IpcChannels from "./ipc/channels.ts";
 
@@ -35,6 +35,15 @@ contextBridge.exposeInMainWorld("desktopBridge", {
     }
     return result as ReturnType<DesktopBridge["getAppBranding"]>;
   },
+  getPathForFile: (file: File) => {
+    // Throws for a File that never came from the OS (e.g. built by the page).
+    try {
+      const path = webUtils.getPathForFile(file);
+      return path.length > 0 ? path : null;
+    } catch {
+      return null;
+    }
+  },
   getSystemLocale: () => {
     const result = ipcRenderer.sendSync(IpcChannels.GET_SYSTEM_LOCALE_CHANNEL);
     return typeof result === "string" ? result : null;

apps/web/src/components/chat/ChatComposer.tsx

@@ -122,6 +122,7 @@ import {
   submitComposerDraft,
 } from "./composerSubmission";
 import { ComposerPromptLengthValidation } from "./ComposerPromptLengthValidation";
+import { formatDroppedFilePaths } from "./droppedFilePaths";
 
 type ComposerCommandMenuPosition = {
   bottom: number;
@@ -2563,6 +2564,37 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     void addComposerImages(imageFiles);
   };
 
+  /**
+   * Insert dropped non-image files as filesystem paths. Only the desktop app
+   * can resolve a path from a dropped File, so in a browser tab this reports
+   * why nothing was inserted instead of silently swallowing the drop.
+   */
+  const insertDroppedFilePaths = (files: File[]) => {
+    const resolvePath = window.desktopBridge?.getPathForFile;
+    if (!resolvePath) {
+      setThreadError(
+        activeThreadId,
+        "Attaching files by path needs the desktop app. Paste an image, or type the path.",
+      );
+      return;
+    }
+    const paths = files
+      .map((file) => resolvePath(file))
+      .filter((path): path is string => path !== null);
+    const text = formatDroppedFilePaths(paths);
+    if (text.length === 0) {
+      setThreadError(activeThreadId, "Could not read the location of the dropped file(s).");
+      return;
+    }
+    if (!insertComposerTextAtEnd(text, { ensureLeadingBoundary: true })) {
+      toastManager.add({
+        type: "error",
+        title: "Unable to add to chat",
+        description: "The composer is busy; try again once it is ready.",
+      });
+    }
+  };
+
   const insertComposerTextAtEnd = (
     text: string,
     options?: { ensureLeadingBoundary?: boolean },
@@ -2686,7 +2718,23 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
         composerEditorRef.current?.focusAt(cursor);
       },
       addDroppedFiles: (files: File[]) => {
-        void addComposerImages(files);
+        // Images become attachments; everything else (audio, PDF, video, …) is
+        // handed over as a path so the agent opens it from disk itself.
+        const images = files.filter((file) => file.type.startsWith("image/"));
+        const nonImages = files.filter((file) => !file.type.startsWith("image/"));
+        if (images.length > 0) {
+          void addComposerImages(images);
+        }
+        if (nonImages.length > 0) {
+          // Deliberately no focusComposer() on this path. `applyPromptReplacement`
+          // focuses on the next frame, once Lexical has reconciled; focusing
+          // synchronously here makes the not-yet-reconciled editor sync its stale
+          // empty state back over the text we just inserted, so the drop looks
+          // like it silently did nothing. Same footgun the file-tree mention drop
+          // documents in makeComposerMentionDragHandlers.
+          insertDroppedFilePaths(nonImages);
+          return;
+        }
         focusComposer();
       },
       insertTextAtEnd: insertComposerTextAtEnd,

apps/web/src/components/chat/droppedFilePaths.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { formatDroppedFilePaths, quoteDroppedFilePath } from "./droppedFilePaths";
+
+describe("quoteDroppedFilePath", () => {
+  it("leaves a path without whitespace alone", () => {
+    expect(quoteDroppedFilePath("/Users/me/notes.pdf")).toBe("/Users/me/notes.pdf");
+  });
+
+  it("quotes a path containing spaces", () => {
+    expect(quoteDroppedFilePath("/Users/me/Voice Memos/note 1.m4a")).toBe(
+      '"/Users/me/Voice Memos/note 1.m4a"',
+    );
+  });
+});
+
+describe("formatDroppedFilePaths", () => {
+  it("joins several paths with a space", () => {
+    expect(formatDroppedFilePaths(["/a/one.opus", "/b/two.pdf"])).toBe("/a/one.opus /b/two.pdf");
+  });
+
+  it("skips empty and whitespace-only entries", () => {
+    expect(formatDroppedFilePaths(["", "   ", "/a/one.opus"])).toBe("/a/one.opus");
+  });
+
+  it("returns an empty string when nothing resolved", () => {
+    expect(formatDroppedFilePaths([])).toBe("");
+  });
+});

apps/web/src/components/chat/droppedFilePaths.ts

@@ -0,0 +1,31 @@
+/**
+ * Files dropped from the OS that aren't images are handed to the agent by
+ * *path*, not by content: it can open the file itself, so a 40MB recording or
+ * a PDF never has to cross the wire as an attachment. This mirrors dropping a
+ * file into a terminal, where the shell receives the path.
+ *
+ * Paths are only available in the desktop app (Electron's `webUtils`); in a
+ * browser tab the File object carries no filesystem path at all.
+ */
+
+/**
+ * Quote a path for the prompt when whitespace would make where it ends
+ * ambiguous. This is prompt text, not a shell command — the goal is a clear
+ * boundary for the reader, not shell-injection safety.
+ */
+export function quoteDroppedFilePath(path: string): string {
+  return /\s/.test(path) ? `"${path}"` : path;
+}
+
+/**
+ * The text inserted into the composer for a set of dropped paths. Empty and
+ * whitespace-only paths are dropped (a bridge that can't resolve a file
+ * returns null, which the caller filters, but be defensive about "" too).
+ */
+export function formatDroppedFilePaths(paths: ReadonlyArray<string>): string {
+  return paths
+    .map((path) => path.trim())
+    .filter((path) => path.length > 0)
+    .map(quoteDroppedFilePath)
+    .join(" ");
+}

packages/contracts/src/ipc.ts

@@ -1070,6 +1070,13 @@ export interface DesktopBridge {
    * regardless of OS settings.
    */
   getSystemLocale?: () => string | null;
+  /**
+   * The filesystem path of a dropped/pasted `File`, which the renderer cannot
+   * read for itself (Electron removed `File.path` in v32). Returns null when
+   * the object has no path — e.g. a file synthesised in-page rather than
+   * dragged in from the OS.
+   */
+  getPathForFile?: (file: File) => string | null;
   // One bootstrap per pool instance currently registered with bootstrap
   // info (omits instances whose backend hasn't produced a config yet).
   // The primary backend is identified by id === PRIMARY_LOCAL_ENVIRONMENT_ID.