pi-image-tools 1.0.2 → 1.0.4

package/src/clipboard.ts

@@ -1,117 +1,385 @@
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-
-import type { ClipboardImage, ClipboardModule } from "./types.js";
-
-const require = createRequire(import.meta.url);
-
-let cachedClipboardModule: ClipboardModule | null | undefined;
-
-function loadClipboardModule(): ClipboardModule | null {
-  if (cachedClipboardModule !== undefined) {
-    return cachedClipboardModule;
-  }
-
-  try {
-    cachedClipboardModule = require("@mariozechner/clipboard") as ClipboardModule;
-  } catch {
-    cachedClipboardModule = null;
-  }
-
-  return cachedClipboardModule;
-}
-
-async function readClipboardImageViaNativeModule(): Promise<ClipboardImage | null> {
-  const clipboard = loadClipboardModule();
-  if (!clipboard || !clipboard.hasImage()) {
-    return null;
-  }
-
-  const imageData = await clipboard.getImageBinary();
-  if (!imageData || imageData.length === 0) {
-    return null;
-  }
-
-  const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
-  return { bytes, mimeType: "image/png" };
-}
-
-function encodePowerShell(script: string): string {
-  return Buffer.from(script, "utf16le").toString("base64");
-}
-
-function readClipboardImageViaPowerShell(): ClipboardImage | null {
-  const script = `
-$ErrorActionPreference = 'Stop'
-Add-Type -AssemblyName System.Windows.Forms
-Add-Type -AssemblyName System.Drawing
-
-if (-not [System.Windows.Forms.Clipboard]::ContainsImage()) {
-  return
-}
-
-$image = [System.Windows.Forms.Clipboard]::GetImage()
-if ($null -eq $image) {
-  return
-}
-
-$stream = New-Object System.IO.MemoryStream
-try {
-  $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
-  [System.Convert]::ToBase64String($stream.ToArray())
-} finally {
-  $stream.Dispose()
-  $image.Dispose()
-}
-`;
-
-  const result = spawnSync(
-    "powershell.exe",
-    [
-      "-NoProfile",
-      "-NonInteractive",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-STA",
-      "-EncodedCommand",
-      encodePowerShell(script),
-    ],
-    {
-      encoding: "utf8",
-      timeout: 6000,
-      maxBuffer: 50 * 1024 * 1024,
-      windowsHide: true,
-    },
-  );
-
-  if (result.error || result.status !== 0) {
-    return null;
-  }
-
-  const base64 = result.stdout.trim();
-  if (!base64) {
-    return null;
-  }
-
-  try {
-    const bytes = Buffer.from(base64, "base64");
-    if (bytes.length === 0) {
-      return null;
-    }
-    return { bytes: new Uint8Array(bytes), mimeType: "image/png" };
-  } catch {
-    return null;
-  }
-}
-
-export async function readClipboardImage(platform: NodeJS.Platform = process.platform): Promise<ClipboardImage | null> {
-  if (platform !== "win32") {
-    return null;
-  }
-
-  try {
-    return (await readClipboardImageViaNativeModule()) ?? readClipboardImageViaPowerShell();
-  } catch {
-    return readClipboardImageViaPowerShell();
-  }
-}
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+
+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;
+
+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 {
+    cachedClipboardModule = null;
+  }
+
+  return cachedClipboardModule;
+}
+
+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 { available: true, image: null };
+  }
+
+  const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
+  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(): ClipboardReadResult {
+  const script = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+if (-not [System.Windows.Forms.Clipboard]::ContainsImage()) {
+  return
+}
+
+$image = [System.Windows.Forms.Clipboard]::GetImage()
+if ($null -eq $image) {
+  return
+}
+
+$stream = New-Object System.IO.MemoryStream
+try {
+  $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+  [System.Convert]::ToBase64String($stream.ToArray())
+} finally {
+  $stream.Dispose()
+  $image.Dispose()
+}
+`;
+
+  const result = spawnSync(
+    "powershell.exe",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-STA",
+      "-EncodedCommand",
+      encodePowerShell(script),
+    ],
+    {
+      encoding: "utf8",
+      timeout: READ_TIMEOUT_MS,
+      maxBuffer: MAX_BUFFER_BYTES,
+      windowsHide: true,
+    },
+  );
+
+  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 { available: true, image: null };
+  }
+
+  try {
+    const bytes = Buffer.from(base64, "base64");
+    if (bytes.length === 0) {
+      return { available: true, image: null };
+    }
+
+    return {
+      available: true,
+      image: {
+        bytes: new Uint8Array(bytes),
+        mimeType: "image/png",
+      },
+    };
+  } catch {
+    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(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;
+  }
+
+  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));
+}

package/src/commands.ts

@@ -1,79 +1,79 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-
-import type { PasteImageCommandHandlers } from "./types.js";
-
-const SUBCOMMAND_CLIPBOARD = "clipboard";
-const SUBCOMMAND_RECENT = "recent";
-
-const ARGUMENT_COMPLETIONS = [
-  {
-    value: SUBCOMMAND_CLIPBOARD,
-    label: SUBCOMMAND_CLIPBOARD,
-    description: "Attach image from clipboard",
-  },
-  {
-    value: SUBCOMMAND_RECENT,
-    label: SUBCOMMAND_RECENT,
-    description: "Open recent images picker and attach selected image",
-  },
-  {
-    value: "help",
-    label: "help",
-    description: "Show usage",
-  },
-] as const;
-
-function parseArgs(args: string): string[] {
-  return args
-    .trim()
-    .split(/\s+/)
-    .map((token) => token.trim().toLowerCase())
-    .filter((token) => token.length > 0);
-}
-
-function usageMessage(): string {
-  return "Usage: /paste-image [clipboard|recent]";
-}
-
-export function registerPasteImageCommand(
-  pi: ExtensionAPI,
-  handlers: PasteImageCommandHandlers,
-): void {
-  pi.registerCommand("paste-image", {
-    description: "Attach an image from clipboard or use a recent-image picker",
-    getArgumentCompletions: (argumentPrefix) => {
-      const normalized = argumentPrefix.trim().toLowerCase();
-      if (!normalized) {
-        return [...ARGUMENT_COMPLETIONS];
-      }
-
-      const matches = ARGUMENT_COMPLETIONS.filter((item) => item.value.startsWith(normalized));
-      return matches.length > 0 ? matches.map((item) => ({ ...item })) : null;
-    },
-    handler: async (args, ctx) => {
-      const tokens = parseArgs(args);
-
-      if (tokens.length === 0 || tokens[0] === SUBCOMMAND_CLIPBOARD) {
-        await handlers.fromClipboard(ctx);
-        return;
-      }
-
-      if (tokens[0] === SUBCOMMAND_RECENT) {
-        if (tokens.length > 1) {
-          ctx.ui.notify(usageMessage(), "warning");
-          return;
-        }
-
-        await handlers.fromRecent(ctx);
-        return;
-      }
-
-      if (tokens[0] === "help") {
-        ctx.ui.notify(usageMessage(), "info");
-        return;
-      }
-
-      ctx.ui.notify(usageMessage(), "warning");
-    },
-  });
-}
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+import type { PasteImageCommandHandlers } from "./types.js";
+
+const SUBCOMMAND_CLIPBOARD = "clipboard";
+const SUBCOMMAND_RECENT = "recent";
+
+const ARGUMENT_COMPLETIONS = [
+  {
+    value: SUBCOMMAND_CLIPBOARD,
+    label: SUBCOMMAND_CLIPBOARD,
+    description: "Attach image from clipboard",
+  },
+  {
+    value: SUBCOMMAND_RECENT,
+    label: SUBCOMMAND_RECENT,
+    description: "Open recent images picker and attach selected image",
+  },
+  {
+    value: "help",
+    label: "help",
+    description: "Show usage",
+  },
+] as const;
+
+function parseArgs(args: string): string[] {
+  return args
+    .trim()
+    .split(/\s+/)
+    .map((token) => token.trim().toLowerCase())
+    .filter((token) => token.length > 0);
+}
+
+function usageMessage(): string {
+  return "Usage: /paste-image [clipboard|recent]";
+}
+
+export function registerPasteImageCommand(
+  pi: ExtensionAPI,
+  handlers: PasteImageCommandHandlers,
+): void {
+  pi.registerCommand("paste-image", {
+    description: "Attach an image from clipboard or use a recent-image picker",
+    getArgumentCompletions: (argumentPrefix) => {
+      const normalized = argumentPrefix.trim().toLowerCase();
+      if (!normalized) {
+        return [...ARGUMENT_COMPLETIONS];
+      }
+
+      const matches = ARGUMENT_COMPLETIONS.filter((item) => item.value.startsWith(normalized));
+      return matches.length > 0 ? matches.map((item) => ({ ...item })) : null;
+    },
+    handler: async (args, ctx) => {
+      const tokens = parseArgs(args);
+
+      if (tokens.length === 0 || tokens[0] === SUBCOMMAND_CLIPBOARD) {
+        await handlers.fromClipboard(ctx);
+        return;
+      }
+
+      if (tokens[0] === SUBCOMMAND_RECENT) {
+        if (tokens.length > 1) {
+          ctx.ui.notify(usageMessage(), "warning");
+          return;
+        }
+
+        await handlers.fromRecent(ctx);
+        return;
+      }
+
+      if (tokens[0] === "help") {
+        ctx.ui.notify(usageMessage(), "info");
+        return;
+      }
+
+      ctx.ui.notify(usageMessage(), "warning");
+    },
+  });
+}