pi-image-tools 1.3.0 → 1.3.1

package/src/providers/types.ts

@@ -1,24 +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>;
-}
+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

@@ -1,81 +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),
-      },
-    };
-  }
-}
+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

@@ -1,87 +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 };
-  }
-}
+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/recent-images.ts

@@ -462,6 +462,7 @@ export function loadRecentImage(
 ): ClipboardImage {
   assertImageWithinByteLimit(candidate.sizeBytes, `Recent image ${candidate.name}`, environment);
   const raw = readFileSync(candidate.path);
+  assertImageWithinByteLimit(raw.length, `Recent image ${candidate.name}`, environment);
   if (raw.length === 0) {
     throw new Error(`File is empty: ${candidate.path}`);
   }

package/src/shell-environment.ts

@@ -1,75 +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 };
-  }
-}
+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 };
+  }
+}