[Init] Initial commit - NetMesh terminal manager

components/terminal/terminalClipboardPaste.ts

@@ -0,0 +1,160 @@
+import type { Terminal as XTerm } from "@xterm/xterm";
+
+import {
+  handleRemoteClipboardImageUpload,
+  type RemoteClipboardImageBridge,
+  type RemoteClipboardImageUploadResult,
+} from "./clipboardImagePaste";
+import { extractRootPathsFromClipboardFiles } from "./terminalHelpers";
+import { pasteTextIntoTerminal } from "./runtime/terminalUserPaste";
+import { logger } from "../../lib/logger";
+
+/** ASCII Ctrl+V - forwarded so nested TUIs can run their own image-paste bindings. */
+export const LOCAL_CLIPBOARD_IMAGE_CTRL_V = "\u0016";
+
+type ClipboardFileBridge = Pick<
+  Partial<NetcattyBridge>,
+  "readClipboardFiles" | "hasClipboardImage"
+>;
+
+type TerminalClipboardPasteOptions = {
+  bridge?: ClipboardFileBridge;
+  /**
+   * When true, a clipboard image is uploaded to the remote host (SFTP) and
+   * the remote path is pasted, instead of falling back to a text paste.
+   * Callers should only enable this for connections that support remote
+   * image paste; the upload no-ops unless a session id is provided.
+   */
+  autoUploadClipboardImage?: boolean;
+  clipboardImageBridge?: RemoteClipboardImageBridge;
+  getRemoteCwd?: () => Promise<string | null | undefined>;
+  isLocalConnection: boolean;
+  isSensitiveInput?: () => boolean;
+  onClipboardImageUploadResult?: (result: RemoteClipboardImageUploadResult) => void;
+  onPasteData?: (data: string) => boolean | void;
+  readClipboardText: () => Promise<string>;
+  scrollOnPaste?: boolean;
+  scrollToBottomAfterProgrammaticInput?: (data: string) => void;
+  sessionId: string | null | undefined;
+  terminalBackend: {
+    writeToSession: (sessionId: string, data: string, options?: { automated?: boolean; sensitive?: boolean }) => void;
+  };
+  term: Pick<XTerm, "paste" | "scrollToBottom"> & Partial<Pick<XTerm, "focus">>;
+};
+
+export async function handleTerminalClipboardPaste({
+  bridge,
+  autoUploadClipboardImage = false,
+  clipboardImageBridge,
+  getRemoteCwd,
+  isLocalConnection,
+  isSensitiveInput,
+  onClipboardImageUploadResult,
+  onPasteData,
+  readClipboardText,
+  scrollOnPaste = false,
+  scrollToBottomAfterProgrammaticInput,
+  sessionId,
+  terminalBackend,
+  term,
+}: TerminalClipboardPasteOptions): Promise<void> {
+  // Image-first: when enabled and a remote session is active, a clipboard
+  // image triggers the SFTP upload flow. "no-image" means the clipboard
+  // holds text/files instead, so we silently continue to the normal paste.
+  if (autoUploadClipboardImage && sessionId && !isLocalConnection) {
+    try {
+      const result = await handleRemoteClipboardImageUpload({
+        bridge: clipboardImageBridge,
+        getRemoteCwd: getRemoteCwd ?? (async () => undefined),
+        isSensitiveInput,
+        sessionId,
+        terminalBackend,
+        term,
+        scrollToBottomAfterProgrammaticInput,
+      });
+      if (result.ok === true) {
+        onClipboardImageUploadResult?.(result);
+        return;
+      }
+      if (result.reason !== "no-image" && result.reason !== "unsupported") {
+        onClipboardImageUploadResult?.(result);
+        return;
+      }
+    } catch {
+      // The clipboard image was already read successfully above, so any throw
+      // here means the upload itself failed (e.g. SFTP cannot be opened for
+      // the session). Surface the same error as the context-menu action
+      // instead of silently pasting unrelated clipboard content.
+      onClipboardImageUploadResult?.({ ok: false, reason: "upload-failed" });
+      return;
+    }
+  }
+
+  const readClipboardFiles = bridge?.readClipboardFiles;
+  if (isLocalConnection && readClipboardFiles) {
+    try {
+      const files = await readClipboardFiles();
+      if (files.length > 0 && sessionId) {
+        const paths = extractRootPathsFromClipboardFiles(files);
+        if (paths.length > 0) {
+          const pathsText = paths.join(" ");
+          terminalBackend.writeToSession(sessionId, pathsText, {
+            sensitive: isSensitiveInput?.() === true,
+          });
+          scrollToBottomAfterProgrammaticInput?.(pathsText);
+          term.focus?.();
+          return;
+        }
+      }
+    } catch {
+      // Fall through to text paste.
+    }
+  }
+
+  let text = "";
+  try {
+    text = await readClipboardText();
+  } catch (error) {
+    // Text read failed (permissions / image-only clipboard quirks). Treat as
+    // empty so local image probe can still forward Ctrl+V.
+    logger.warn("Failed to read clipboard text for terminal paste", error);
+  }
+  // Prefer real text paste. Whitespace-only is deferred until after the local
+  // image probe so screenshot clipboards that also carry blank text/plain can
+  // still forward Ctrl+V for nested TUIs.
+  if (text.trim() && sessionId) {
+    pasteTextIntoTerminal(term, text, {
+      scrollOnPaste,
+      onPasteData,
+    });
+    return;
+  }
+
+  // Local image-only clipboard: Electron's Edit>Paste turns Ctrl+V into a
+  // paste event, so TUI apps (Claude Code chat:imagePaste, etc.) never see
+  // the chord. Forward raw Ctrl+V; the app can then read the OS clipboard
+  // via xclip/wl-paste. Skip remote sessions - the image is not on the host.
+  if (isLocalConnection && sessionId && bridge?.hasClipboardImage) {
+    try {
+      if (await bridge.hasClipboardImage()) {
+        terminalBackend.writeToSession(sessionId, LOCAL_CLIPBOARD_IMAGE_CTRL_V, {
+          sensitive: isSensitiveInput?.() === true,
+        });
+        scrollToBottomAfterProgrammaticInput?.(LOCAL_CLIPBOARD_IMAGE_CTRL_V);
+        term.focus?.();
+        return;
+      }
+    } catch {
+      // Clipboard probe failed; fall through to whitespace text paste if any.
+    }
+  }
+
+  // Preserve intentional whitespace-only pastes (indent / newline) when no
+  // local clipboard image is present.
+  if (text && sessionId) {
+    pasteTextIntoTerminal(term, text, {
+      scrollOnPaste,
+      onPasteData,
+    });
+  }
+}