pi-image-tools 1.2.0 → 1.3.0

package/src/providers/mac-osascript-publicpng.ts

@@ -0,0 +1,77 @@
+import { buildNamespaceWrappedCommand, defaultCommandExists, type CommandExists } from "../shell-environment.js";
+import {
+  defaultCommandRunner,
+  MAX_BUFFER_BYTES,
+  READ_TIMEOUT_MS,
+  type CommandRunner,
+} from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+const PUBLIC_PNG_SCRIPT = `ObjC.import('AppKit');
+const pasteboard = $.NSPasteboard.generalPasteboard;
+const data = pasteboard.dataForType('public.png');
+if (!data) {
+  $.exit(2);
+}
+$.NSFileHandle.fileHandleWithStandardOutput.writeData(data);`;
+
+export interface OsascriptPublicPngProviderOptions {
+  priority?: number;
+  commandRunner?: CommandRunner;
+  commandExists?: CommandExists;
+}
+
+export class OsascriptPublicPngProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly commandRunner: CommandRunner;
+  private readonly commandExists: CommandExists;
+
+  constructor(options: OsascriptPublicPngProviderOptions = {}) {
+    this.capabilities = {
+      id: "mac-osascript-public-png",
+      name: "osascript public.png",
+      platforms: ["darwin"],
+      priority: options.priority ?? 20,
+    };
+    this.commandRunner = options.commandRunner ?? defaultCommandRunner;
+    this.commandExists = options.commandExists ?? defaultCommandExists;
+  }
+
+  isAvailable(context: ClipboardProviderContext): boolean {
+    try {
+      return this.commandExists("osascript", context);
+    } catch {
+      return false;
+    }
+  }
+
+  read(context: ClipboardProviderContext): ClipboardReadResult {
+    const wrapped = buildNamespaceWrappedCommand(
+      "osascript",
+      ["-l", "JavaScript", "-e", PUBLIC_PNG_SCRIPT],
+      context,
+      this.commandExists,
+    );
+    const result = this.commandRunner(wrapped.command, wrapped.args, {
+      environment: context.environment,
+      maxBuffer: MAX_BUFFER_BYTES,
+      timeout: READ_TIMEOUT_MS,
+    });
+
+    if (result.missingCommand) {
+      return { available: false, image: null };
+    }
+
+    if (!result.ok || result.stdout.length === 0) {
+      return { available: true, image: null };
+    }
+
+    return {
+      available: true,
+      image: {
+        bytes: new Uint8Array(result.stdout),
+        mimeType: "image/png",
+      },
+    };
+  }
+}

package/src/providers/mac-pngpaste.ts

@@ -0,0 +1,69 @@
+import { buildNamespaceWrappedCommand, defaultCommandExists, type CommandExists } from "../shell-environment.js";
+import {
+  defaultCommandRunner,
+  MAX_BUFFER_BYTES,
+  READ_TIMEOUT_MS,
+  type CommandRunner,
+} from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+export interface PngpasteProviderOptions {
+  priority?: number;
+  commandRunner?: CommandRunner;
+  commandExists?: CommandExists;
+}
+
+export class PngpasteProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly commandRunner: CommandRunner;
+  private readonly commandExists: CommandExists;
+
+  constructor(options: PngpasteProviderOptions = {}) {
+    this.capabilities = {
+      id: "mac-pngpaste",
+      name: "pngpaste",
+      platforms: ["darwin"],
+      priority: options.priority ?? 10,
+    };
+    this.commandRunner = options.commandRunner ?? defaultCommandRunner;
+    this.commandExists = options.commandExists ?? defaultCommandExists;
+  }
+
+  isAvailable(context: ClipboardProviderContext): boolean {
+    try {
+      return this.commandExists("pngpaste", context);
+    } catch {
+      return false;
+    }
+  }
+
+  read(context: ClipboardProviderContext): ClipboardReadResult {
+    const wrapped = buildNamespaceWrappedCommand(
+      "pngpaste",
+      ["-"],
+      context,
+      this.commandExists,
+    );
+    const result = this.commandRunner(wrapped.command, wrapped.args, {
+      environment: context.environment,
+      maxBuffer: MAX_BUFFER_BYTES,
+      timeout: READ_TIMEOUT_MS,
+    });
+
+    if (result.missingCommand) {
+      return { available: false, image: null };
+    }
+
+    if (!result.ok || result.stdout.length === 0) {
+      return { available: true, image: null };
+    }
+
+    return {
+      available: true,
+      image: {
+        bytes: new Uint8Array(result.stdout),
+        mimeType: "image/png",
+      },
+    };
+  }
+}

package/src/providers/native-module.ts

@@ -0,0 +1,84 @@
+import { createRequire } from "node:module";
+
+import { hasGraphicalSession } from "../shell-environment.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+import type { ClipboardModule } from "../types.js";
+
+const require = createRequire(import.meta.url);
+let cachedClipboardModule: ClipboardModule | null | undefined;
+
+export type ClipboardModuleLoader = (
+  platform: NodeJS.Platform,
+  environment: NodeJS.ProcessEnv,
+) => ClipboardModule | null;
+
+export 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;
+}
+
+export interface NativeModuleProviderOptions {
+  priority?: number;
+  moduleLoader?: ClipboardModuleLoader;
+}
+
+export class NativeModuleProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly moduleLoader: ClipboardModuleLoader;
+
+  constructor(options: NativeModuleProviderOptions = {}) {
+    this.capabilities = {
+      id: "native-module",
+      name: "@mariozechner/clipboard",
+      platforms: "*" as const,
+      priority: options.priority ?? 100,
+    };
+    this.moduleLoader = options.moduleLoader ?? loadClipboardModule;
+  }
+
+  isAvailable(context: ClipboardProviderContext): boolean {
+    return this.moduleLoader(context.platform, context.environment) !== null;
+  }
+
+  async read(context: ClipboardProviderContext): Promise<ClipboardReadResult> {
+    const clipboard = this.moduleLoader(context.platform, context.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",
+      },
+    };
+  }
+}

package/src/providers/powershell-forms.ts

@@ -0,0 +1,95 @@
+import { runPowerShellCommand, type PowerShellCommandResult, type RunPowerShellCommandOptions } from "../powershell.js";
+import { MAX_BUFFER_BYTES, READ_TIMEOUT_MS } from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+export type PowerShellRunner = (
+  script: string,
+  options: RunPowerShellCommandOptions,
+) => PowerShellCommandResult;
+
+export interface PowerShellFormsProviderOptions {
+  priority?: number;
+  powerShellRunner?: PowerShellRunner;
+}
+
+const READ_IMAGE_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()
+}
+`;
+
+export class PowerShellFormsProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly powerShellRunner: PowerShellRunner;
+
+  constructor(options: PowerShellFormsProviderOptions = {}) {
+    this.capabilities = {
+      id: "powershell-forms",
+      name: "Windows PowerShell Forms clipboard",
+      platforms: ["win32"],
+      priority: options.priority ?? 20,
+    };
+    this.powerShellRunner = options.powerShellRunner ?? runPowerShellCommand;
+  }
+
+  isAvailable(_context: ClipboardProviderContext): boolean {
+    return true;
+  }
+
+  read(_context: ClipboardProviderContext): ClipboardReadResult {
+    const result = this.powerShellRunner(READ_IMAGE_SCRIPT, {
+      encoded: true,
+      maxBuffer: MAX_BUFFER_BYTES,
+      sta: true,
+      timeout: READ_TIMEOUT_MS,
+    });
+
+    if (result.missingCommand) {
+      return { available: false, image: null };
+    }
+
+    if (!result.ok) {
+      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 };
+    }
+  }
+}

package/src/providers/registry.ts

@@ -0,0 +1,88 @@
+import type {
+  ClipboardImageProvider,
+  ClipboardProviderContext,
+  ClipboardReadResult,
+} from "./types.js";
+import type { ClipboardImage } from "../types.js";
+
+export interface ClipboardProviderAttempt {
+  providerId: string;
+  available: boolean;
+  imageFound: boolean;
+  skipped: boolean;
+}
+
+export interface ClipboardProviderRegistryReadResult {
+  image: ClipboardImage | null;
+  attempts: ClipboardProviderAttempt[];
+}
+
+function supportsPlatform(provider: ClipboardImageProvider, platform: NodeJS.Platform): boolean {
+  const { platforms } = provider.capabilities;
+  return platforms === "*" || platforms.includes(platform);
+}
+
+function byPriority(left: ClipboardImageProvider, right: ClipboardImageProvider): number {
+  return left.capabilities.priority - right.capabilities.priority;
+}
+
+export class ClipboardProviderRegistry {
+  private readonly providers: ClipboardImageProvider[] = [];
+
+  constructor(providers: readonly ClipboardImageProvider[] = []) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+
+  register(provider: ClipboardImageProvider): this {
+    this.providers.push(provider);
+    return this;
+  }
+
+  getProviders(platform: NodeJS.Platform): ClipboardImageProvider[] {
+    return this.providers.filter((provider) => supportsPlatform(provider, platform)).sort(byPriority);
+  }
+
+  async getEligible(context: ClipboardProviderContext): Promise<ClipboardImageProvider[]> {
+    const eligible: ClipboardImageProvider[] = [];
+    for (const provider of this.getProviders(context.platform)) {
+      if (await provider.isAvailable(context)) {
+        eligible.push(provider);
+      }
+    }
+
+    return eligible;
+  }
+
+  async read(context: ClipboardProviderContext): Promise<ClipboardProviderRegistryReadResult> {
+    const attempts: ClipboardProviderAttempt[] = [];
+
+    for (const provider of this.getProviders(context.platform)) {
+      const isAvailable = await provider.isAvailable(context);
+      if (!isAvailable) {
+        attempts.push({
+          providerId: provider.capabilities.id,
+          available: false,
+          imageFound: false,
+          skipped: true,
+        });
+        continue;
+      }
+
+      const result: ClipboardReadResult = await provider.read(context);
+      attempts.push({
+        providerId: provider.capabilities.id,
+        available: result.available,
+        imageFound: result.image !== null,
+        skipped: false,
+      });
+
+      if (result.image) {
+        return { image: result.image, attempts };
+      }
+    }
+
+    return { image: null, attempts };
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,24 @@
+import type { ClipboardImage } from "../types.js";
+
+export interface ClipboardReadResult {
+  available: boolean;
+  image: ClipboardImage | null;
+}
+
+export interface ClipboardProviderContext {
+  platform: NodeJS.Platform;
+  environment: NodeJS.ProcessEnv;
+}
+
+export interface ProviderCapabilities {
+  readonly id: string;
+  readonly name: string;
+  readonly platforms: readonly NodeJS.Platform[] | "*";
+  readonly priority: number;
+}
+
+export interface ClipboardImageProvider {
+  readonly capabilities: ProviderCapabilities;
+  isAvailable(context: ClipboardProviderContext): boolean | Promise<boolean>;
+  read(context: ClipboardProviderContext): ClipboardReadResult | Promise<ClipboardReadResult>;
+}

package/src/providers/wl-paste.ts

@@ -0,0 +1,81 @@
+import { normalizeMimeType, selectPreferredImageMimeType } from "../image-mime.js";
+import {
+  defaultCommandRunner,
+  LIST_TYPES_TIMEOUT_MS,
+  MAX_BUFFER_BYTES,
+  READ_TIMEOUT_MS,
+  type CommandRunner,
+} from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+export interface WlPasteProviderOptions {
+  priority?: number;
+  commandRunner?: CommandRunner;
+}
+
+export class WlPasteProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly commandRunner: CommandRunner;
+
+  constructor(options: WlPasteProviderOptions = {}) {
+    this.capabilities = {
+      id: "wl-paste",
+      name: "wl-paste",
+      platforms: ["linux"],
+      priority: options.priority ?? 10,
+    };
+    this.commandRunner = options.commandRunner ?? defaultCommandRunner;
+  }
+
+  isAvailable(_context: ClipboardProviderContext): boolean {
+    return true;
+  }
+
+  read(context: ClipboardProviderContext): ClipboardReadResult {
+    const listTypes = this.commandRunner("wl-paste", ["--list-types"], {
+      environment: context.environment,
+      maxBuffer: MAX_BUFFER_BYTES,
+      timeout: 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 = this.commandRunner(
+      "wl-paste",
+      ["--type", selectedMimeType, "--no-newline"],
+      {
+        environment: context.environment,
+        maxBuffer: MAX_BUFFER_BYTES,
+        timeout: 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),
+      },
+    };
+  }
+}

package/src/providers/xclip.ts

@@ -0,0 +1,87 @@
+import { normalizeMimeType, selectPreferredImageMimeType, SUPPORTED_IMAGE_MIME_TYPES } from "../image-mime.js";
+import {
+  defaultCommandRunner,
+  LIST_TYPES_TIMEOUT_MS,
+  MAX_BUFFER_BYTES,
+  READ_TIMEOUT_MS,
+  type CommandRunner,
+} from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+export interface XclipProviderOptions {
+  priority?: number;
+  commandRunner?: CommandRunner;
+}
+
+export class XclipProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly commandRunner: CommandRunner;
+
+  constructor(options: XclipProviderOptions = {}) {
+    this.capabilities = {
+      id: "xclip",
+      name: "xclip",
+      platforms: ["linux"],
+      priority: options.priority ?? 20,
+    };
+    this.commandRunner = options.commandRunner ?? defaultCommandRunner;
+  }
+
+  isAvailable(_context: ClipboardProviderContext): boolean {
+    return true;
+  }
+
+  read(context: ClipboardProviderContext): ClipboardReadResult {
+    const targets = this.commandRunner(
+      "xclip",
+      ["-selection", "clipboard", "-t", "TARGETS", "-o"],
+      {
+        environment: context.environment,
+        maxBuffer: MAX_BUFFER_BYTES,
+        timeout: 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 = this.commandRunner(
+        "xclip",
+        ["-selection", "clipboard", "-t", mimeType, "-o"],
+        {
+          environment: context.environment,
+          maxBuffer: MAX_BUFFER_BYTES,
+          timeout: 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 };
+  }
+}

package/src/shell-environment.ts

@@ -0,0 +1,75 @@
+import { spawnSync } from "node:child_process";
+
+export interface ShellCommandContext {
+  platform: NodeJS.Platform;
+  environment: NodeJS.ProcessEnv;
+}
+
+export type CommandExists = (command: string, context: ShellCommandContext) => boolean;
+
+export interface WrappedCommand {
+  command: string;
+  args: string[];
+  wrapped: boolean;
+}
+
+const COMMAND_EXISTS_TIMEOUT_MS = 1000;
+const COMMAND_EXISTS_MAX_BUFFER_BYTES = 1024 * 1024;
+const commandExistsCache = new Map<string, boolean>();
+
+export function hasGraphicalSession(platform: NodeJS.Platform, environment: NodeJS.ProcessEnv): boolean {
+  return platform !== "linux" || Boolean(environment.DISPLAY || environment.WAYLAND_DISPLAY);
+}
+
+export function isWaylandSession(environment: NodeJS.ProcessEnv): boolean {
+  return Boolean(environment.WAYLAND_DISPLAY) || environment.XDG_SESSION_TYPE === "wayland";
+}
+
+export function isTmuxSession(environment: NodeJS.ProcessEnv): boolean {
+  return Boolean(environment.TMUX);
+}
+
+export const defaultCommandExists: CommandExists = (command, context) => {
+  const lookupCommand = context.platform === "win32" ? "where" : "which";
+  const cacheKey = `${context.platform}:${lookupCommand}:${command}:${context.environment.PATH ?? ""}`;
+  const cached = commandExistsCache.get(cacheKey);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const result = spawnSync(lookupCommand, [command], {
+    env: context.environment,
+    maxBuffer: COMMAND_EXISTS_MAX_BUFFER_BYTES,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: COMMAND_EXISTS_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  const exists = !result.error && result.status === 0;
+  commandExistsCache.set(cacheKey, exists);
+  return exists;
+};
+
+export function buildNamespaceWrappedCommand(
+  command: string,
+  args: readonly string[],
+  context: ShellCommandContext,
+  commandExists: CommandExists = defaultCommandExists,
+): WrappedCommand {
+  try {
+    if (
+      context.platform !== "darwin" ||
+      !isTmuxSession(context.environment) ||
+      !commandExists("reattach-to-user-namespace", context)
+    ) {
+      return { command, args: [...args], wrapped: false };
+    }
+
+    return {
+      command: "reattach-to-user-namespace",
+      args: [command, ...args],
+      wrapped: true,
+    };
+  } catch {
+    return { command, args: [...args], wrapped: false };
+  }
+}