pi-image-tools 1.0.11 → 1.2.0

package/src/index.ts

@@ -1,9 +1,11 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { readClipboardImage } from "./clipboard.js";
 import { registerPasteImageCommand } from "./commands.js";
 import { loadImageToolsConfig } from "./config.js";
 import { DebugLogger } from "./debug-logger.js";
+import { getErrorMessage } from "./errors.js";
+import { assertImageWithinByteLimit } from "./image-size.js";
 import {
   IMAGE_PREVIEW_CUSTOM_TYPE,
   buildPreviewItems,
@@ -27,15 +29,8 @@ const IMAGE_ATTACHMENT_INDICATOR = "[󰈟 Image Attached]";
 
 interface PendingImage extends ImagePayload {}
 
-function getErrorMessage(error: unknown): string {
-  if (error instanceof Error && error.message.trim().length > 0) {
-    return error.message;
-  }
-
-  return "Unknown error";
-}
-
 function imageToBase64(image: ClipboardImage): string {
+  assertImageWithinByteLimit(image.bytes.length, "Image attachment");
   return Buffer.from(image.bytes).toString("base64");
 }
 
@@ -113,12 +108,13 @@ function buildRecentImageEmptyStateMessage(searchedDirectories: readonly string[
   ].join(" ");
 }
 
-function showRecentSelectionPreview(
+async function showRecentSelectionPreview(
   pi: ExtensionAPI,
   image: ClipboardImage,
   cwd: string,
-): void {
-  const previewItems = buildPreviewItems(
+  logger: DebugLogger,
+): Promise<void> {
+  const previewItems = await buildPreviewItems(
     [
       {
         type: "image",
@@ -126,7 +122,7 @@ function showRecentSelectionPreview(
         mimeType: image.mimeType,
       },
     ],
-    { cwd },
+    { cwd, logger },
   );
 
   if (previewItems.length === 0) {
@@ -155,8 +151,8 @@ export default function imageToolsExtension(pi: ExtensionAPI): void {
     pasteImageShortcutsConfigured: config.shortcuts.pasteImage !== undefined,
   });
 
-  registerInlineUserImagePreview(pi);
-  registerImagePreviewDisplay(pi);
+  registerInlineUserImagePreview(pi, { logger });
+  registerImagePreviewDisplay(pi, { logger });
 
   const pasteImageFromClipboard = async (ctx: PasteContext): Promise<void> => {
     if (!ctx.hasUI) {
@@ -214,11 +210,9 @@ export default function imageToolsExtension(pi: ExtensionAPI): void {
       const selectedCandidate = discovery.candidates[selectedIndex];
       const selectedImage = loadRecentImage(selectedCandidate);
 
-      try {
-        showRecentSelectionPreview(pi, selectedImage, ctx.cwd);
-      } catch (error) {
+      void showRecentSelectionPreview(pi, selectedImage, ctx.cwd, logger).catch((error: unknown) => {
         ctx.ui.notify(`Could not render recent image preview: ${getErrorMessage(error)}`, "warning");
-      }
+      });
 
       queueImageAttachment(
         ctx,

package/src/inline-user-preview.ts

@@ -2,9 +2,12 @@ import {
   type ExtensionAPI,
   InteractiveMode,
   UserMessageComponent,
-} from "@mariozechner/pi-coding-agent";
-import { Image, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-coding-agent";
+import { Image, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
+import { isRecord } from "./config.js";
+import type { DebugLogger } from "./debug-logger.js";
+import { getErrorMessage } from "./errors.js";
 import { buildPreviewItems, type ImagePayload, type ImagePreviewItem } from "./image-preview.js";
 import { buildSixelRenderLines, isInlineImageProtocolLine } from "./sixel-protocol.js";
 import { setActiveTerminalImageSettingsCwd } from "./terminal-image-width.js";
@@ -108,19 +111,15 @@ function renderPreviewLines(items: readonly ImagePreviewItem[], width: number):
 }
 
 function toUserMessage(value: unknown): UserMessageLike {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-
-  return value as UserMessageLike;
+  return isRecord(value) ? value : {};
 }
 
 function toImageContent(value: unknown): UserImageContent | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
+  if (!isRecord(value)) {
     return null;
   }
 
-  const record = value as Record<string, unknown>;
+  const record = value;
   if (record.type !== "image") {
     return null;
   }
@@ -237,7 +236,19 @@ function assignPreviewItemsToLatestUserMessage(
   }
 }
 
-function patchInteractiveMode(): void {
+function logInlinePreviewError(
+  logger: DebugLogger | undefined,
+  event: string,
+  error: unknown,
+): void {
+  try {
+    logger?.log(event, { error: getErrorMessage(error) });
+  } catch {
+    // Debug logging is best-effort inside Pi event handlers.
+  }
+}
+
+function patchInteractiveMode(logger?: DebugLogger): void {
   const prototype = (InteractiveMode as unknown as { prototype: InteractiveModePrototype }).prototype;
   if (!prototype) {
     return;
@@ -277,15 +288,6 @@ function patchInteractiveMode(): void {
       : 0;
 
     const imagePayloads = extractImagePayloads(message);
-    let previewItems: ImagePreviewItem[] = [];
-    if (imagePayloads.length > 0) {
-      try {
-        previewItems = buildPreviewItems(imagePayloads);
-      } catch {
-        previewItems = [];
-      }
-    }
-
     const original = prototype.__piImageToolsOriginalAddMessageToChat;
     if (!original) {
       return;
@@ -293,41 +295,73 @@ function patchInteractiveMode(): void {
 
     original.call(this, message, options);
 
-    if (previewItems.length === 0) {
+    if (imagePayloads.length === 0) {
       return;
     }
 
-    assignPreviewItemsToLatestUserMessage(mode, beforeCount, previewItems);
+    void buildPreviewItems(imagePayloads, { logger })
+      .then((previewItems) => {
+        if (previewItems.length === 0) {
+          return;
+        }
+
+        assignPreviewItemsToLatestUserMessage(mode, beforeCount, previewItems);
+      })
+      .catch((error: unknown) => {
+        logInlinePreviewError(logger, "inline-user-preview.build_preview_failed", error);
+      });
   };
 
   prototype.__piImageToolsPreviewPatched = true;
 }
 
-export function registerInlineUserImagePreview(pi: ExtensionAPI): void {
-  const schedulePatch = (): void => {
-    setTimeout(() => {
-      patchInteractiveMode();
-      patchUserMessageRender();
-    }, 0);
+export interface RegisterInlineUserImagePreviewOptions {
+  logger?: DebugLogger;
+}
 
+export function registerInlineUserImagePreview(
+  pi: ExtensionAPI,
+  options: RegisterInlineUserImagePreviewOptions = {},
+): void {
+  const runPatch = (delayMs: number): void => {
     setTimeout(() => {
-      patchInteractiveMode();
-      patchUserMessageRender();
-    }, 25);
+      try {
+        patchInteractiveMode(options.logger);
+        patchUserMessageRender();
+      } catch (error) {
+        logInlinePreviewError(options.logger, "inline-user-preview.patch_failed", error);
+      }
+    }, delayMs);
+  };
+
+  const schedulePatch = (): void => {
+    runPatch(0);
+    runPatch(25);
+  };
+
+  const handleSessionEvent = (eventName: string, cwd: string | undefined): void => {
+    try {
+      setActiveTerminalImageSettingsCwd(cwd);
+      schedulePatch();
+    } catch (error) {
+      logInlinePreviewError(options.logger, `inline-user-preview.${eventName}_failed`, error);
+    }
   };
 
   pi.on("session_start", async (_event, ctx) => {
-    setActiveTerminalImageSettingsCwd(ctx.cwd);
-    schedulePatch();
+    handleSessionEvent("session_start", ctx.cwd);
   });
 
   pi.on("before_agent_start", async (_event, ctx) => {
-    setActiveTerminalImageSettingsCwd(ctx.cwd);
-    schedulePatch();
+    handleSessionEvent("before_agent_start", ctx.cwd);
   });
 
-  pi.on("session_switch", async (_event, ctx) => {
-    setActiveTerminalImageSettingsCwd(ctx.cwd);
-    schedulePatch();
+  const onSessionSwitch = pi.on as unknown as (
+    event: "session_switch",
+    handler: (_event: unknown, ctx: { cwd?: string }) => Promise<void>,
+  ) => void;
+
+  onSessionSwitch("session_switch", async (_event, ctx) => {
+    handleSessionEvent("session_switch", ctx.cwd);
   });
 }

package/src/keybindings.ts

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { getAgentDir, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { TUI_KEYBINDINGS, type KeyId, type KeybindingsConfig } from "@mariozechner/pi-tui";
+import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { TUI_KEYBINDINGS, type KeyId, type KeybindingsConfig } from "@earendil-works/pi-tui";
 
 import { isRecord, type ImageToolsConfig } from "./config.js";
 import type { DebugLogger } from "./debug-logger.js";

package/src/powershell.ts

@@ -0,0 +1,222 @@
+import { spawn, spawnSync } from "node:child_process";
+
+import { getErrorMessage, isErrnoException } from "./errors.js";
+
+export interface PowerShellCommandResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  missingCommand: boolean;
+  reason?: string;
+}
+
+export interface BufferedCommandResult {
+  status: number | null;
+  stdout: Buffer;
+  stderr: Buffer;
+  error?: Error;
+}
+
+export interface RunBufferedCommandOptions {
+  maxBuffer: number;
+  timeout: number;
+  windowsHide?: boolean;
+}
+
+export interface RunPowerShellCommandOptions {
+  args?: string[];
+  encoded?: boolean;
+  maxBuffer: number;
+  sta?: boolean;
+  timeout: number;
+}
+
+function encodePowerShell(script: string): string {
+  return Buffer.from(script, "utf16le").toString("base64");
+}
+
+export function runBufferedCommand(
+  command: string,
+  args: readonly string[],
+  options: RunBufferedCommandOptions,
+): Promise<BufferedCommandResult> {
+  return new Promise((resolve) => {
+    let child: ReturnType<typeof spawn>;
+    try {
+      child = spawn(command, [...args], {
+        windowsHide: options.windowsHide,
+      });
+    } catch (error) {
+      resolve({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        error: error instanceof Error ? error : new Error(String(error)),
+      });
+      return;
+    }
+
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let processError: Error | undefined;
+
+    const finish = (result: BufferedCommandResult): void => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      clearTimeout(timeout);
+      resolve(result);
+    };
+
+    const failAndKill = (error: Error): void => {
+      processError = error;
+      child.kill();
+    };
+
+    const appendChunk = (chunks: Buffer[], chunk: unknown, currentBytes: number): number => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+      const nextBytes = currentBytes + buffer.length;
+      if (nextBytes > options.maxBuffer && !processError) {
+        failAndKill(new Error(`Command output exceeded maxBuffer (${options.maxBuffer} bytes).`));
+        return nextBytes;
+      }
+
+      chunks.push(buffer);
+      return nextBytes;
+    };
+
+    const timeout = setTimeout(() => {
+      failAndKill(new Error(`Command timed out after ${options.timeout}ms.`));
+    }, options.timeout);
+    timeout.unref?.();
+
+    child.stdout?.on("data", (chunk: unknown) => {
+      stdoutBytes = appendChunk(stdoutChunks, chunk, stdoutBytes);
+    });
+
+    child.stderr?.on("data", (chunk: unknown) => {
+      stderrBytes = appendChunk(stderrChunks, chunk, stderrBytes);
+    });
+
+    child.on("error", (error: Error) => {
+      processError = error;
+      finish({
+        status: null,
+        stdout: Buffer.concat(stdoutChunks),
+        stderr: Buffer.concat(stderrChunks),
+        error: processError,
+      });
+    });
+
+    child.on("close", (status: number | null) => {
+      finish({
+        status,
+        stdout: Buffer.concat(stdoutChunks),
+        stderr: Buffer.concat(stderrChunks),
+        error: processError,
+      });
+    });
+  });
+}
+
+export function runPowerShellCommand(
+  script: string,
+  options: RunPowerShellCommandOptions,
+): PowerShellCommandResult {
+  if (process.platform !== "win32") {
+    return {
+      ok: false,
+      stdout: "",
+      stderr: "",
+      missingCommand: false,
+      reason: "PowerShell is only available through pi-image-tools on Windows.",
+    };
+  }
+
+  const commandArgs = [
+    "-NoProfile",
+    "-NonInteractive",
+    ...(options.sta ? ["-STA"] : []),
+    ...(options.encoded ? ["-EncodedCommand", encodePowerShell(script)] : ["-Command", script]),
+    ...(options.args ?? []),
+  ];
+
+  const result = spawnSync("powershell.exe", commandArgs, {
+    encoding: "utf8",
+    timeout: options.timeout,
+    maxBuffer: options.maxBuffer,
+    windowsHide: true,
+  });
+
+  if (result.error) {
+    return {
+      ok: false,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      missingCommand: isErrnoException(result.error) && result.error.code === "ENOENT",
+      reason: getErrorMessage(result.error),
+    };
+  }
+
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    missingCommand: false,
+    reason: result.status === 0 ? undefined : `PowerShell exited with code ${result.status}`,
+  };
+}
+
+export async function runPowerShellCommandAsync(
+  script: string,
+  options: RunPowerShellCommandOptions,
+): Promise<PowerShellCommandResult> {
+  if (process.platform !== "win32") {
+    return {
+      ok: false,
+      stdout: "",
+      stderr: "",
+      missingCommand: false,
+      reason: "PowerShell is only available through pi-image-tools on Windows.",
+    };
+  }
+
+  const commandArgs = [
+    "-NoProfile",
+    "-NonInteractive",
+    ...(options.sta ? ["-STA"] : []),
+    ...(options.encoded ? ["-EncodedCommand", encodePowerShell(script)] : ["-Command", script]),
+    ...(options.args ?? []),
+  ];
+
+  const result = await runBufferedCommand("powershell.exe", commandArgs, {
+    timeout: options.timeout,
+    maxBuffer: options.maxBuffer,
+    windowsHide: true,
+  });
+  const stdout = result.stdout.toString("utf8");
+  const stderr = result.stderr.toString("utf8");
+
+  if (result.error) {
+    return {
+      ok: false,
+      stdout,
+      stderr,
+      missingCommand: isErrnoException(result.error) && result.error.code === "ENOENT",
+      reason: getErrorMessage(result.error),
+    };
+  }
+
+  return {
+    ok: result.status === 0,
+    stdout,
+    stderr,
+    missingCommand: false,
+    reason: result.status === 0 ? undefined : `PowerShell exited with code ${result.status}`,
+  };
+}

package/src/recent-images.ts

@@ -11,6 +11,8 @@ import {
 import { homedir, tmpdir } from "node:os";
 import { basename, extname, join, resolve } from "node:path";
 
+import { extensionToMimeType, mimeTypeToExtension } from "./image-mime.js";
+import { assertImageWithinByteLimit, formatByteLimit } from "./image-size.js";
 import type { ClipboardImage } from "./types.js";
 
 export const RECENT_IMAGE_ENV_VAR = "PI_IMAGE_TOOLS_RECENT_DIRS";
@@ -30,15 +32,6 @@ const SCREENSHOT_NAME_PATTERNS: readonly RegExp[] = [
   /^スクリーンショット/i,
 ];
 
-const EXTENSION_TO_MIME = new Map<string, string>([
-  [".png", "image/png"],
-  [".jpg", "image/jpeg"],
-  [".jpeg", "image/jpeg"],
-  [".webp", "image/webp"],
-  [".gif", "image/gif"],
-  [".bmp", "image/bmp"],
-]);
-
 interface RecentImageSource {
   path: string;
   filterScreenshotNames: boolean;
@@ -193,27 +186,11 @@ function isLikelyScreenshotName(name: string): boolean {
 }
 
 function toMimeType(fileName: string): string | null {
-  const extension = extname(fileName).toLowerCase();
-  return EXTENSION_TO_MIME.get(extension) ?? null;
+  return extensionToMimeType(extname(fileName));
 }
 
-function extensionForMimeType(mimeType: string): string {
-  const normalized = mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
-
-  switch (normalized) {
-    case "image/png":
-      return "png";
-    case "image/jpeg":
-      return "jpg";
-    case "image/webp":
-      return "webp";
-    case "image/gif":
-      return "gif";
-    case "image/bmp":
-      return "bmp";
-    default:
-      return "png";
-  }
+function isExtensionOwnedCacheFileName(name: string): boolean {
+  return /^pi-recent-\d+-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.[a-z0-9]+$/i.test(name);
 }
 
 function listRecentImagesFromSource(source: RecentImageSource): RecentImageCandidate[] {
@@ -372,7 +349,7 @@ function pruneCacheDirectory(cacheDirectory: string, maxCacheFiles: number): voi
           return null;
         }
 
-        if (!toMimeType(name)) {
+        if (!isExtensionOwnedCacheFileName(name) || !toMimeType(name)) {
           return null;
         }
 
@@ -406,8 +383,9 @@ export function persistImageToRecentCache(
   }
 
   const environment = options.environment ?? process.env;
+  assertImageWithinByteLimit(image.bytes.length, "Cached image", environment);
   const cacheDirectory = getRecentImageCacheDirectory(environment);
-  const extension = extensionForMimeType(image.mimeType);
+  const extension = mimeTypeToExtension(image.mimeType);
 
   mkdirSync(cacheDirectory, { recursive: true });
 
@@ -451,23 +429,6 @@ function formatRelativeAge(modifiedAtMs: number, nowMs: number): string {
   return `${deltaYears}y ago`;
 }
 
-function formatSize(sizeBytes: number): string {
-  if (sizeBytes < 1024) {
-    return `${sizeBytes} B`;
-  }
-
-  const units = ["KB", "MB", "GB"] as const;
-  let value = sizeBytes / 1024;
-  let unitIndex = 0;
-
-  while (value >= 1024 && unitIndex < units.length - 1) {
-    value /= 1024;
-    unitIndex += 1;
-  }
-
-  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unitIndex]}`;
-}
-
 function detectPathSeparator(pathValue: string): string {
   return pathValue.includes("\\") ? "\\" : "/";
 }
@@ -489,13 +450,17 @@ function abbreviatePath(pathValue: string, maxChars: number): string {
 
 export function formatRecentImageLabel(candidate: RecentImageCandidate, nowMs = Date.now()): string {
   const age = formatRelativeAge(candidate.modifiedAtMs, nowMs);
-  const size = formatSize(candidate.sizeBytes);
+  const size = formatByteLimit(candidate.sizeBytes);
   const shortPath = abbreviatePath(candidate.path, 64);
 
   return `${candidate.name} • ${age} • ${size} • ${shortPath}`;
 }
 
-export function loadRecentImage(candidate: RecentImageCandidate): ClipboardImage {
+export function loadRecentImage(
+  candidate: RecentImageCandidate,
+  environment: NodeJS.ProcessEnv = process.env,
+): ClipboardImage {
+  assertImageWithinByteLimit(candidate.sizeBytes, `Recent image ${candidate.name}`, environment);
   const raw = readFileSync(candidate.path);
   if (raw.length === 0) {
     throw new Error(`File is empty: ${candidate.path}`);

package/src/terminal-image-width.ts

@@ -1,6 +1,8 @@
-import { SettingsManager, getAgentDir } from "@mariozechner/pi-coding-agent";
+import { SettingsManager, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { resolve } from "node:path";
 
+import { isRecord } from "./config.js";
+
 export const DEFAULT_TERMINAL_IMAGE_WIDTH_CELLS = 60;
 
 export interface TerminalImageWidthOptions {
@@ -42,7 +44,7 @@ function normalizeImageWidthCells(value: unknown): number {
 }
 
 function readRawImageWidthCells(settings: unknown): unknown {
-  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+  if (!isRecord(settings)) {
     return undefined;
   }
 

package/src/types.ts

@@ -1,20 +1,20 @@
-import type { ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
-
-export type PasteContext = ExtensionContext | ExtensionCommandContext;
-
-export interface ClipboardImage {
-  bytes: Uint8Array;
-  mimeType: string;
-}
-
-export interface ClipboardModule {
-  hasImage: () => boolean;
-  getImageBinary: () => Promise<Array<number> | Uint8Array>;
-}
-
-export type PasteImageHandler = (ctx: PasteContext) => Promise<void>;
-
-export interface PasteImageCommandHandlers {
-  fromClipboard: PasteImageHandler;
-  fromRecent: PasteImageHandler;
-}
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type PasteContext = ExtensionContext | ExtensionCommandContext;
+
+export interface ClipboardImage {
+  bytes: Uint8Array;
+  mimeType: string;
+}
+
+export interface ClipboardModule {
+  hasImage: () => boolean;
+  getImageBinary: () => Promise<Array<number> | Uint8Array>;
+}
+
+export type PasteImageHandler = (ctx: PasteContext) => Promise<void>;
+
+export interface PasteImageCommandHandlers {
+  fromClipboard: PasteImageHandler;
+  fromRecent: PasteImageHandler;
+}