pi-image-tools 1.0.3 → 1.0.5

package/src/clipboard.ts

@@ -5,13 +5,76 @@ import type { ClipboardImage, ClipboardModule } from "./types.js";
 
 const require = createRequire(import.meta.url);
 
+const LIST_TYPES_TIMEOUT_MS = 1000;
+const READ_TIMEOUT_MS = 5000;
+const MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+const SUPPORTED_IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif",
+  "image/bmp",
+] as const;
+
 let cachedClipboardModule: ClipboardModule | null | undefined;
 
-function loadClipboardModule(): ClipboardModule | null {
+interface CommandResult {
+  ok: boolean;
+  stdout: Buffer;
+  missingCommand: boolean;
+}
+
+interface ClipboardReadResult {
+  available: boolean;
+  image: ClipboardImage | null;
+}
+
+function isErrnoException(error: Error): error is NodeJS.ErrnoException {
+  return "code" in error;
+}
+
+function hasGraphicalSession(platform: NodeJS.Platform, environment: NodeJS.ProcessEnv): boolean {
+  return platform !== "linux" || Boolean(environment.DISPLAY || environment.WAYLAND_DISPLAY);
+}
+
+function isWaylandSession(environment: NodeJS.ProcessEnv): boolean {
+  return Boolean(environment.WAYLAND_DISPLAY) || environment.XDG_SESSION_TYPE === "wayland";
+}
+
+function normalizeMimeType(mimeType: string): string {
+  return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+
+function selectPreferredImageMimeType(mimeTypes: readonly string[]): string | null {
+  const normalized = mimeTypes
+    .map((mimeType) => mimeType.trim())
+    .filter((mimeType) => mimeType.length > 0)
+    .map((mimeType) => ({ raw: mimeType, normalized: normalizeMimeType(mimeType) }));
+
+  for (const preferredMimeType of SUPPORTED_IMAGE_MIME_TYPES) {
+    const match = normalized.find((mimeType) => mimeType.normalized === preferredMimeType);
+    if (match) {
+      return match.raw;
+    }
+  }
+
+  const firstImage = normalized.find((mimeType) => mimeType.normalized.startsWith("image/"));
+  return firstImage?.raw ?? null;
+}
+
+function loadClipboardModule(
+  platform: NodeJS.Platform = process.platform,
+  environment: NodeJS.ProcessEnv = process.env,
+): ClipboardModule | null {
   if (cachedClipboardModule !== undefined) {
     return cachedClipboardModule;
   }
 
+  if (environment.TERMUX_VERSION || !hasGraphicalSession(platform, environment)) {
+    cachedClipboardModule = null;
+    return cachedClipboardModule;
+  }
+
   try {
     cachedClipboardModule = require("@mariozechner/clipboard") as ClipboardModule;
   } catch {
@@ -21,26 +84,68 @@ function loadClipboardModule(): ClipboardModule | null {
   return cachedClipboardModule;
 }
 
-async function readClipboardImageViaNativeModule(): Promise<ClipboardImage | null> {
-  const clipboard = loadClipboardModule();
-  if (!clipboard || !clipboard.hasImage()) {
-    return null;
+async function readClipboardImageViaNativeModule(
+  platform: NodeJS.Platform,
+  environment: NodeJS.ProcessEnv,
+): Promise<ClipboardReadResult> {
+  const clipboard = loadClipboardModule(platform, environment);
+  if (!clipboard) {
+    return { available: false, image: null };
+  }
+
+  if (!clipboard.hasImage()) {
+    return { available: true, image: null };
   }
 
   const imageData = await clipboard.getImageBinary();
   if (!imageData || imageData.length === 0) {
-    return null;
+    return { available: true, image: null };
   }
 
   const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
-  return { bytes, mimeType: "image/png" };
+  return {
+    available: true,
+    image: {
+      bytes,
+      mimeType: "image/png",
+    },
+  };
+}
+
+function runCommand(
+  command: string,
+  args: string[],
+  timeout: number,
+): CommandResult {
+  const result = spawnSync(command, args, {
+    timeout,
+    maxBuffer: MAX_BUFFER_BYTES,
+  });
+
+  if (result.error) {
+    return {
+      ok: false,
+      stdout: Buffer.alloc(0),
+      missingCommand: isErrnoException(result.error) && result.error.code === "ENOENT",
+    };
+  }
+
+  const stdout = Buffer.isBuffer(result.stdout)
+    ? result.stdout
+    : Buffer.from(result.stdout ?? "", typeof result.stdout === "string" ? "utf8" : undefined);
+
+  return {
+    ok: result.status === 0,
+    stdout,
+    missingCommand: false,
+  };
 }
 
 function encodePowerShell(script: string): string {
   return Buffer.from(script, "utf16le").toString("base64");
 }
 
-function readClipboardImageViaPowerShell(): ClipboardImage | null {
+function readClipboardImageViaPowerShell(): ClipboardReadResult {
   const script = `
 $ErrorActionPreference = 'Stop'
 Add-Type -AssemblyName System.Windows.Forms
@@ -78,40 +183,203 @@ try {
     ],
     {
       encoding: "utf8",
-      timeout: 6000,
-      maxBuffer: 50 * 1024 * 1024,
+      timeout: READ_TIMEOUT_MS,
+      maxBuffer: MAX_BUFFER_BYTES,
       windowsHide: true,
     },
   );
 
-  if (result.error || result.status !== 0) {
-    return null;
+  if (result.error) {
+    return {
+      available: !isErrnoException(result.error) || result.error.code !== "ENOENT",
+      image: null,
+    };
+  }
+
+  if (result.status !== 0) {
+    return { available: true, image: null };
   }
 
   const base64 = result.stdout.trim();
   if (!base64) {
-    return null;
+    return { available: true, image: null };
   }
 
   try {
     const bytes = Buffer.from(base64, "base64");
     if (bytes.length === 0) {
-      return null;
+      return { available: true, image: null };
     }
-    return { bytes: new Uint8Array(bytes), mimeType: "image/png" };
+
+    return {
+      available: true,
+      image: {
+        bytes: new Uint8Array(bytes),
+        mimeType: "image/png",
+      },
+    };
   } catch {
-    return null;
+    return { available: true, image: null };
+  }
+}
+
+function readClipboardImageViaWlPaste(): ClipboardReadResult {
+  const listTypes = runCommand("wl-paste", ["--list-types"], LIST_TYPES_TIMEOUT_MS);
+  if (listTypes.missingCommand) {
+    return { available: false, image: null };
+  }
+
+  if (!listTypes.ok) {
+    return { available: true, image: null };
+  }
+
+  const mimeTypes = listTypes.stdout
+    .toString("utf8")
+    .split(/\r?\n/)
+    .map((mimeType) => mimeType.trim())
+    .filter((mimeType) => mimeType.length > 0);
+
+  const selectedMimeType = selectPreferredImageMimeType(mimeTypes);
+  if (!selectedMimeType) {
+    return { available: true, image: null };
+  }
+
+  const imageData = runCommand(
+    "wl-paste",
+    ["--type", selectedMimeType, "--no-newline"],
+    READ_TIMEOUT_MS,
+  );
+
+  if (!imageData.ok || imageData.stdout.length === 0) {
+    return { available: true, image: null };
+  }
+
+  return {
+    available: true,
+    image: {
+      bytes: new Uint8Array(imageData.stdout),
+      mimeType: normalizeMimeType(selectedMimeType),
+    },
+  };
+}
+
+function readClipboardImageViaXclip(): ClipboardReadResult {
+  const targets = runCommand(
+    "xclip",
+    ["-selection", "clipboard", "-t", "TARGETS", "-o"],
+    LIST_TYPES_TIMEOUT_MS,
+  );
+
+  if (targets.missingCommand) {
+    return { available: false, image: null };
+  }
+
+  const advertisedMimeTypes = targets.ok
+    ? targets.stdout
+        .toString("utf8")
+        .split(/\r?\n/)
+        .map((mimeType) => mimeType.trim())
+        .filter((mimeType) => mimeType.length > 0)
+    : [];
+
+  const preferredMimeType =
+    advertisedMimeTypes.length > 0 ? selectPreferredImageMimeType(advertisedMimeTypes) : null;
+  const mimeTypesToTry = preferredMimeType
+    ? [preferredMimeType, ...SUPPORTED_IMAGE_MIME_TYPES]
+    : [...SUPPORTED_IMAGE_MIME_TYPES];
+
+  for (const mimeType of mimeTypesToTry) {
+    const imageData = runCommand(
+      "xclip",
+      ["-selection", "clipboard", "-t", mimeType, "-o"],
+      READ_TIMEOUT_MS,
+    );
+
+    if (imageData.ok && imageData.stdout.length > 0) {
+      return {
+        available: true,
+        image: {
+          bytes: new Uint8Array(imageData.stdout),
+          mimeType: normalizeMimeType(mimeType),
+        },
+      };
+    }
+  }
+
+  return { available: true, image: null };
+}
+
+function getUnavailableReaderMessage(platform: NodeJS.Platform): string {
+  switch (platform) {
+    case "linux":
+      return "No Linux clipboard image reader is available. Install wl-clipboard or xclip, or ensure @mariozechner/clipboard is installed.";
+    case "darwin":
+      return "No macOS clipboard image reader is available. Ensure @mariozechner/clipboard is installed.";
+    case "win32":
+      return "No Windows clipboard image reader is available. Ensure PowerShell is available or @mariozechner/clipboard is installed.";
+    default:
+      return `Clipboard image paste is not supported on platform: ${platform}`;
   }
 }
 
-export async function readClipboardImage(platform: NodeJS.Platform = process.platform): Promise<ClipboardImage | null> {
-  if (platform !== "win32") {
+export async function readClipboardImage(options?: {
+  environment?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
+}): Promise<ClipboardImage | null> {
+  const environment = options?.environment ?? process.env;
+  const platform = options?.platform ?? process.platform;
+
+  if (environment.TERMUX_VERSION) {
     return null;
   }
 
-  try {
-    return (await readClipboardImageViaNativeModule()) ?? readClipboardImageViaPowerShell();
-  } catch {
-    return readClipboardImageViaPowerShell();
+  if (!hasGraphicalSession(platform, environment)) {
+    throw new Error("Clipboard image paste requires a graphical desktop session with DISPLAY or WAYLAND_DISPLAY.");
+  }
+
+  const readerResults: ClipboardReadResult[] = [];
+
+  const recordResult = (result: ClipboardReadResult): ClipboardImage | null => {
+    readerResults.push(result);
+    return result.image;
+  };
+
+  if (platform === "win32") {
+    const nativeImage = recordResult(await readClipboardImageViaNativeModule(platform, environment));
+    if (nativeImage) {
+      return nativeImage;
+    }
+
+    const powerShellImage = recordResult(readClipboardImageViaPowerShell());
+    if (powerShellImage) {
+      return powerShellImage;
+    }
+  } else if (platform === "linux") {
+    const sessionReaders = isWaylandSession(environment)
+      ? [readClipboardImageViaWlPaste, readClipboardImageViaXclip]
+      : [readClipboardImageViaXclip, readClipboardImageViaWlPaste];
+
+    for (const reader of sessionReaders) {
+      const image = recordResult(reader());
+      if (image) {
+        return image;
+      }
+    }
+
+    const nativeImage = recordResult(await readClipboardImageViaNativeModule(platform, environment));
+    if (nativeImage) {
+      return nativeImage;
+    }
+  } else {
+    const nativeImage = recordResult(await readClipboardImageViaNativeModule(platform, environment));
+    if (nativeImage) {
+      return nativeImage;
+    }
   }
+
+  if (readerResults.some((result) => result.available)) {
+    return null;
+  }
+
+  throw new Error(getUnavailableReaderMessage(platform));
 }