refactor: rewrite ImageShowTool with new architecture

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/tools/ImageShowTool/ImageShowTool.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env bun
+/**
+ * Visual test: display a local image or URL using ink-picture + Ink.
+ *
+ * Usage:
+ *   bun run src/ink-picture/__tests__/LocalPicture.test.tsx [path|url]
+ *
+ * Examples:
+ *   bun run src/ink-picture/__tests__/LocalPicture.test.tsx ~/Pictures/IMAGE/image.png
+ *   bun run src/ink-picture/__tests__/LocalPicture.test.tsx https://example.com/image.jpg
+ */
+
+import { Jimp } from "jimp";
+import React, { useEffect, useState } from "react";
+import { render, Box, Text, useApp } from "ink";
+import Image, { InkPictureProvider } from "../../ink-picture/index.ts";
+import { loadImageFromUrl } from "../../ink-picture/utils/jimpURL.ts";
+
+// 终端字符尺寸（像素）
+const CELL_WIDTH = 8;
+const CELL_HEIGHT = 16;
+
+// 获取命令行参数
+const args = process.argv.slice(2);
+const IMAGE_PATH = args[0] || "/home/yuki/Pictures/Wallpapers/3god.jpg";
+
+// 判断是 URL 还是本地路径
+const isUrl = IMAGE_PATH.startsWith("http://") || IMAGE_PATH.startsWith("https://");
+
+// 加载图片（支持本地和 URL）
+async function loadImage(path: string) {
+  if (isUrl) {
+    return loadImageFromUrl(path);
+  } else {
+    return Jimp.read(path);
+  }
+}
+
+function App() {
+  const { exit } = useApp();
+  const [dimensions, setDimensions] = useState<{
+    width: number;
+    height: number;
+    pixelWidth: number;
+    pixelHeight: number;
+  } | null>(null);
+  const [err, setErr] = useState(false);
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const image = await loadImage(IMAGE_PATH);
+        const origW = image.bitmap.width;
+        const origH = image.bitmap.height;
+        const cols = process.stdout.columns ?? 80;
+
+        const targetW_chars = Math.floor(cols * 0.1618);
+        const targetW_pixels = targetW_chars * CELL_WIDTH;
+        const targetH_pixels = Math.floor(targetW_pixels * (origH / origW));
+        const minH_pixels = 3 * CELL_HEIGHT;
+        const finalH_pixels = Math.max(targetH_pixels, minH_pixels);
+        const targetH_chars = Math.ceil(finalH_pixels / CELL_HEIGHT);
+
+        setDimensions({
+          width: targetW_chars,
+          height: targetH_chars,
+          pixelWidth: targetW_pixels,
+          pixelHeight: finalH_pixels,
+        });
+      } catch (e) {
+        console.error(e);
+        setErr(true);
+        exit();
+      }
+    })();
+  }, []);
+
+  useEffect(() => {
+    const handleSigint = () => exit();
+    process.on("SIGINT", handleSigint);
+    return () => process.off("SIGINT", handleSigint);
+  }, [exit]);
+
+  if (err) {
+    return <Text color="red" > Failed to fetch: { IMAGE_PATH } </Text>;
+  }
+
+  if (!dimensions) {
+    return <Text>Loading...</Text>;
+  }
+
+  return (
+    <Box flexDirection= "column" >
+    <InkPictureProvider>
+    <Image
+          src={ IMAGE_PATH }
+  width = { dimensions.width }
+  height = { dimensions.height }
+  pixelWidth = { dimensions.pixelWidth }
+  pixelHeight = { dimensions.pixelHeight }
+  alt = { isUrl? "url-image": "local-image" }
+    />
+    </InkPictureProvider>
+    </Box>
+  );
+}
+
+const { waitUntilExit } = render(<App />);
+await waitUntilExit();

src/tools/ImageShowTool/ImageShowTool.tsx

@@ -1,288 +0,0 @@
-import { homedir } from 'os'
-import React from 'react'
-import { z } from 'zod/v4'
-import { Jimp } from 'jimp'
-import { Text } from '../../ink.js'
-import { buildTool, type ToolDef } from '../../Tool.js'
-import { logForDebugging } from '../../utils/debug.js'
-import Image, { InkPictureProvider, type TerminalInfo } from 'src/ink-picture/index.ts'
-import { loadImageFromUrl } from 'src/ink-picture/utils/jimpURL.ts'
-
-const IMAGE_TOOL_NAME = 'ImageShow'
-
-const inputSchema = () =>
-  z.strictObject({
-    url: z
-      .string()
-      .describe(
-        'Image URL (https://...) or local file path (e.g. /tmp/image.png). ' +
-          'Supported formats: PNG, JPEG, GIF, WebP.',
-      ),
-    alt: z
-      .string()
-      .optional()
-      .describe('Alt text shown as link when image cannot be displayed.'),
-  })
-
-type Input = z.infer<ReturnType<typeof inputSchema>>
-
-/** Standard terminal cell size in pixels */
-const CELL_WIDTH = 8
-const CELL_HEIGHT = 16
-
-/**
- * Lightweight synchronous Kitty graphics protocol detection.
- * Uses only env vars — no module dependencies, no async queries.
- */
-function detectKittySync(): boolean {
-  return !!(
-    process.env.TERM?.includes('kitty') ||
-    process.env.KITTY_WINDOW_ID ||
-    process.env.TERM_PROGRAM === 'kitty' ||
-    process.env.TERM_PROGRAM === 'ghostty' ||
-    process.env.TERM_PROGRAM === 'WezTerm' ||
-    process.env.TERM_PROGRAM === 'konsole' ||
-    process.env.TERM_PROGRAM === 'foot'
-  )
-}
-
-function getToolUseSummary(input: Partial<Input>): string | null {
-  return input?.url ? `Show: ${input.url.split('/').pop() ?? input.url}` : null
-}
-
-/** Normalize image source path: expand ~, strip file:// */
-function normalizeSrc(url: string): string {
-  let src = url
-  if (src.startsWith('~')) {
-    src = src.replace(/^~(?=$|\/)/, homedir())
-  }
-  if (src.startsWith('file://')) {
-    src = src.slice(7)
-  }
-  return src
-}
-
-/** Load image from local path or URL, returning Jimp instance */
-async function loadImage(src: string): Promise<Jimp> {
-  if (src.startsWith('http://') || src.startsWith('https://')) {
-    return loadImageFromUrl(src)
-  }
-  return Jimp.read(src)
-}
-
-export const ImageShowTool = buildTool({
-  name: IMAGE_TOOL_NAME,
-  description:
-    'Display an image (PNG/JPEG/GIF/WebP) directly in the terminal. ' +
-    'Renders with full-resolution via Kitty Graphics Protocol when supported, ' +
-    'with automatic fallback to text-based rendering (half-block, braille, ascii).',
-
-  getToolUseSummary,
-  getActivityDescription(input) {
-    return input?.url ? `Showing image: ${input.url}` : 'Showing image'
-  },
-
-  isEnabled() {
-    return true
-  },
-
-  get inputSchema() {
-    return inputSchema()
-  },
-
-  async validateInput(input) {
-    if (!input?.url) {
-      return { result: false, message: 'Missing url', errorCode: 1 }
-    }
-    return { result: true }
-  },
-
-  async prompt(_options): Promise<string> {
-    return `ImageShow displays a PNG/JPEG/GIF/WebP image directly in the terminal using Unicode-block rendering. Supports local file paths (e.g. /tmp/image.png) and HTTPS URLs (e.g. https://example.com/image.png). The image is rendered within Ink's virtual DOM so the cursor stays in sync.`
-  },
-
-  async checkPermissions(): Promise<{ behavior: 'allow' }> {
-    return { behavior: 'allow' }
-  },
-
-  isReadOnly() {
-    return true
-  },
-
-  isConcurrencySafe() {
-    return true
-  },
-
-  mapToolResultToToolResultBlockParam(
-    content: {
-      success: boolean
-      message: string
-      imageData?: { base64: string; mediaType: string }
-    },
-    toolUseID: string,
-  ) {
-    if (content.success && content.imageData) {
-      return {
-        tool_use_id: toolUseID,
-        type: 'tool_result' as const,
-        content: [
-          {
-            type: 'image' as const,
-            source: {
-              type: 'base64' as const,
-              data: content.imageData.base64,
-              media_type: content.imageData.mediaType as 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp',
-            },
-          },
-        ],
-      }
-    }
-    return {
-      tool_use_id: toolUseID,
-      type: 'tool_result' as const,
-      content: [
-        {
-          type: 'text' as const,
-          text: content.message,
-        },
-      ],
-    }
-  },
-
-  renderToolResultMessage(
-    content: {
-      success: boolean
-      message: string
-      src?: string
-      alt?: string
-      naturalWidth?: number
-      naturalHeight?: number
-      base64?: string
-    },
-    _progressMessages,
-    _options,
-  ): React.ReactNode {
-    if (!content.success) {
-      return null
-    }
-
-    if (content.src) {
-      const cols = process.stdout.columns ?? 80
-      const rows = process.stdout.rows ?? 40
-
-      // Target: 60% of terminal width
-      const targetW_chars = Math.floor(cols * 0.6)
-      const targetW_pixels = targetW_chars * CELL_WIDTH
-
-      // Compute height from original aspect ratio if available
-      let pixelHeight: number
-      let imgHeight: number
-
-      if (content.naturalWidth && content.naturalHeight) {
-        const targetH_pixels = Math.floor(
-          targetW_pixels * (content.naturalHeight / content.naturalWidth),
-        )
-        const minH_pixels = 3 * CELL_HEIGHT
-        pixelHeight = Math.max(targetH_pixels, minH_pixels)
-        imgHeight = Math.ceil(pixelHeight / CELL_HEIGHT)
-      } else {
-        // Fallback: 40% of terminal height
-        imgHeight = Math.floor(rows * 0.4)
-        pixelHeight = imgHeight * CELL_HEIGHT
-      }
-
-      // Use the already-loaded PNG buffer to avoid a second file read
-      // inside the Image component. This is more reliable in the compiled binary.
-      const imageSrc = content.base64
-        ? Buffer.from(content.base64, 'base64')
-        : content.src
-
-      // Sync terminal info prevents InkPictureProvider's async terminal
-      // query from delaying the first render and ensures the correct
-      // protocol is used from frame one.
-      const terminalInfo: Partial<TerminalInfo> = {
-        supportsKittyGraphics: detectKittySync(),
-        supportsUnicode: true,
-      }
-
-      return (
-        <InkPictureProvider terminalInfo={terminalInfo}>
-          <Image
-            src={imageSrc}
-            width={targetW_chars}
-            height={imgHeight}
-            pixelWidth={targetW_pixels}
-            pixelHeight={pixelHeight}
-            alt={content.alt}
-          />
-        </InkPictureProvider>
-      )
-    }
-
-    return <Text dimColor>{content.message}</Text>
-  },
-
-  async call(input: Input): Promise<{
-    data: {
-      success: boolean
-      message: string
-      imageData?: { base64: string; mediaType: string }
-      base64?: string
-      src?: string
-      alt?: string
-      naturalWidth?: number
-      naturalHeight?: number
-    }
-  }> {
-    const url = input.url
-    const alt = input.alt ?? url.split('/').pop() ?? 'image'
-
-    const src = normalizeSrc(url)
-    logForDebugging(`ImageShow: loading ${url}`)
-
-    try {
-      const image = await loadImage(src)
-      const naturalWidth = image.bitmap.width
-      const naturalHeight = image.bitmap.height
-
-      const buffer = await image.getBuffer('image/png')
-
-      if (buffer.length > 10_000_000) {
-        logForDebugging(`ImageShow: image too large (${buffer.length} bytes)`)
-        return {
-          data: {
-            success: false,
-            message: `Image too large (${(buffer.length / 1024 / 1024).toFixed(1)} MB). Max 10 MB.`,
-          },
-        }
-      }
-
-      logForDebugging(`ImageShow: loaded ${buffer.length} byte PNG, ${naturalWidth}x${naturalHeight}`)
-
-      return {
-        data: {
-          success: true,
-          message: `Displayed: ${alt} (${buffer.length} bytes, PNG, ${naturalWidth}x${naturalHeight})`,
-          imageData: {
-            base64: buffer.toString('base64'),
-            mediaType: 'image/png',
-          },
-          base64: buffer.toString('base64'),
-          src,
-          alt,
-          naturalWidth,
-          naturalHeight,
-        },
-      }
-    } catch (err) {
-      const errMsg = err instanceof Error ? `${err.name}: ${err.message}` : String(err)
-      logForDebugging(`ImageShow: load error ${errMsg} for ${url}`)
-      return {
-        data: {
-          success: false,
-          message: `Failed to fetch: ${url} (${errMsg})`,
-        },
-      }
-    }
-  },
-}) satisfies ToolDef<any, any>

src/tools/ImageShowTool/__tests__/ImageShowTool.test.ts

@@ -1,343 +0,0 @@
-import { describe, it, expect, beforeAll, vi } from 'vitest'
-import { ImageShowTool } from '../ImageShowTool'
-import { readFile } from 'fs/promises'
-import { homedir } from 'os'
-import path from 'path'
-import React from 'react'
-import type { Text } from 'ink'
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function getExampleImagePath(): string {
-  const rel = path.join('src', 'ink-picture', 'examples', 'images', 'house.png')
-  return path.resolve(__dirname, '..', '..', '..', '..', rel)
-}
-
-function writeTempPng(): string {
-  // Minimal valid 1x1 red PNG (baked base64)
-  const pngBase64 =
-    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=='
-  const tmpFile = path.join(
-    process.env.TMPDIR || process.env.TEMP || '/tmp',
-    `imgshow-test-${Date.now()}.png`,
-  )
-  require('fs').writeFileSync(tmpFile, Buffer.from(pngBase64, 'base64'))
-  return tmpFile
-}
-
-// ── Suite ────────────────────────────────────────────────────────────────────
-
-describe('ImageShowTool – comprehensive', () => {
-  let imagePath: string
-
-  beforeAll(async () => {
-    imagePath = getExampleImagePath()
-    const exists = await readFile(imagePath).catch(() => null)
-    expect(exists).not.toBeNull()
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  Metadata
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('metadata', () => {
-    it('has correct name', () => {
-      expect(ImageShowTool.name).toBe('ImageShow')
-    })
-
-    it('is enabled', () => {
-      expect(ImageShowTool.isEnabled()).toBe(true)
-    })
-
-    it('is read only', () => {
-      expect(ImageShowTool.isReadOnly()).toBe(true)
-    })
-
-    it('is concurrency safe', () => {
-      expect(ImageShowTool.isConcurrencySafe()).toBe(true)
-    })
-
-    it('returns a prompt string', async () => {
-      const prompt = await ImageShowTool.prompt({} as any)
-      expect(typeof prompt).toBe('string')
-      expect(prompt.length).toBeGreaterThan(0)
-      expect(prompt.toLowerCase()).toContain('image')
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  Input validation
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('validateInput', () => {
-    it('accepts a valid local path', async () => {
-      const r = await ImageShowTool.validateInput({ url: imagePath })
-      expect(r.result).toBe(true)
-    })
-
-    it('accepts a remote URL', async () => {
-      const r = await ImageShowTool.validateInput({
-        url: 'https://example.com/img.png',
-      })
-      expect(r.result).toBe(true)
-    })
-
-    it('rejects missing url key', async () => {
-      const r = await ImageShowTool.validateInput({} as any)
-      expect(r.result).toBe(false)
-      expect(r.message).toMatch(/missing/i)
-      expect(r.errorCode).toBe(1)
-    })
-
-    it('rejects undefined input', async () => {
-      const r = await ImageShowTool.validateInput(undefined as any)
-      expect(r.result).toBe(false)
-      expect(r.message).toMatch(/missing/i)
-    })
-
-    it('rejects empty string url', async () => {
-      const r = await ImageShowTool.validateInput({ url: '' })
-      expect(r.result).toBe(false)
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  call — local files
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('call – local files', () => {
-    it('loads a PNG and returns base64 + metadata', async () => {
-      const result = await ImageShowTool.call({ url: imagePath })
-
-      expect(result.data.success).toBe(true)
-      expect(result.data.message).toContain('house.png')
-
-      // imageData
-      expect(result.data.imageData).toBeDefined()
-      expect(result.data.imageData!.mediaType).toBe('image/png')
-      expect(typeof result.data.imageData!.base64).toBe('string')
-      expect(result.data.imageData!.base64.length).toBeGreaterThan(0)
-
-      // base64 top-level alias
-      expect(result.data.base64).toBe(result.data.imageData!.base64)
-
-      // src – should be the raw file-system path
-      expect(result.data.src).toBe(imagePath)
-
-      // alt – defaults to filename
-      expect(result.data.alt).toBe('house.png')
-    })
-
-    it('handles file:// protocol', async () => {
-      const result = await ImageShowTool.call({ url: `file://${imagePath}` })
-      expect(result.data.success).toBe(true)
-      expect(result.data.imageData!.mediaType).toBe('image/png')
-      // src is normalized (file:// stripped)
-      expect(result.data.src).toBe(imagePath)
-    })
-
-    it('expands ~ to homedir', async () => {
-      // Write a temp PNG in the home dir so the ~ path resolves
-      const home = homedir()
-      const tmpFile = writeTempPng()
-      const homeFile = path.join(home, path.basename(tmpFile))
-      try {
-        require('fs').renameSync(tmpFile, homeFile)
-      } catch {
-        // home dir not writable — skip
-        require('fs').unlinkSync(tmpFile)
-        return
-      }
-
-      const result = await ImageShowTool.call({
-        url: `~/${path.basename(homeFile)}`,
-      })
-      expect(result.data.success).toBe(true)
-
-      // Cleanup
-      try { require('fs').unlinkSync(homeFile) } catch {}
-    })
-
-    it('uses custom alt text', async () => {
-      const result = await ImageShowTool.call({
-        url: imagePath,
-        alt: 'My House',
-      })
-      expect(result.data.alt).toBe('My House')
-    })
-
-    it('fails gracefully for non-existent file', async () => {
-      const result = await ImageShowTool.call({
-        url: '/tmp/__nonexistent_img_test_file__xyz.png',
-      })
-      expect(result.data.success).toBe(false)
-      expect(result.data.message).toMatch(/fail/i)
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  call — remote URLs
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('call – remote URLs', () => {
-    it('fails gracefully for unreachable URL', async () => {
-      // Temporarily mock fetch to reject quickly
-      const origFetch = globalThis.fetch
-      globalThis.fetch = vi.fn().mockRejectedValue(new Error('fetch failed'))
-      try {
-        const result = await ImageShowTool.call({
-          url: 'https://example.com/img.png',
-        })
-        expect(result.data.success).toBe(false)
-        expect(result.data.message).toMatch(/fail/i)
-      } finally {
-        globalThis.fetch = origFetch
-      }
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  getToolUseSummary
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('getToolUseSummary', () => {
-    it('returns null for empty input', () => {
-      expect(ImageShowTool.getToolUseSummary({} as any)).toBeNull()
-    })
-
-    it('includes filename from path', () => {
-      const s = ImageShowTool.getToolUseSummary({ url: imagePath })
-      expect(s).toBe(`Show: house.png`)
-    })
-
-    it('includes filename from remote URL', () => {
-      const s = ImageShowTool.getToolUseSummary({
-        url: 'https://example.com/photo.jpg',
-      })
-      expect(s).toBe('Show: photo.jpg')
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  getActivityDescription
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('getActivityDescription', () => {
-    it('returns generic string without input', () => {
-      expect(ImageShowTool.getActivityDescription({} as any)).toBe(
-        'Showing image',
-      )
-    })
-
-    it('includes URL in description', () => {
-      const d = ImageShowTool.getActivityDescription({ url: imagePath })
-      expect(d).toContain(imagePath)
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  mapToolResultToToolResultBlockParam
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('mapToolResultToToolResultBlockParam', () => {
-    it('returns image block on success with imageData', () => {
-      const content = {
-        success: true,
-        message: 'ok',
-        imageData: { base64: 'abc123', mediaType: 'image/png' },
-      }
-      const mapped = ImageShowTool.mapToolResultToToolResultBlockParam(
-        content as any,
-        'tool-use-42',
-      )
-      expect(mapped.tool_use_id).toBe('tool-use-42')
-      expect(mapped.content).toHaveLength(1)
-      const block = mapped.content[0]!
-      expect(block.type).toBe('image')
-      if (block.type === 'image') {
-        expect(block.source.type).toBe('base64')
-        expect(block.source.data).toBe('abc123')
-        expect(block.source.media_type).toBe('image/png')
-      }
-    })
-
-    it('returns image block with JPEG type', () => {
-      const content = {
-        success: true,
-        message: 'ok',
-        imageData: { base64: 'xyz', mediaType: 'image/jpeg' },
-      }
-      const mapped = ImageShowTool.mapToolResultToToolResultBlockParam(
-        content as any,
-        'tid',
-      )
-      const block = mapped.content[0]!
-      expect(block.type).toBe('image')
-      if (block.type === 'image') {
-        expect(block.source.media_type).toBe('image/jpeg')
-      }
-    })
-
-    it('returns text block on failure (no imageData)', () => {
-      const content = { success: false, message: 'Failed to load image' }
-      const mapped = ImageShowTool.mapToolResultToToolResultBlockParam(
-        content as any,
-        'tid',
-      )
-      expect(mapped.content).toHaveLength(1)
-      const block = mapped.content[0]!
-      expect(block.type).toBe('text')
-      if (block.type === 'text') {
-        expect(block.text).toBe('Failed to load image')
-      }
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  renderToolResultMessage
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('renderToolResultMessage', () => {
-    it('returns null when success is false', () => {
-      const node = ImageShowTool.renderToolResultMessage(
-        { success: false, message: 'error' },
-        [],
-        {} as any,
-      )
-      expect(node).toBeNull()
-    })
-
-    it('returns InkPictureProvider/Image element when src is provided', () => {
-      const node = ImageShowTool.renderToolResultMessage(
-        { success: true, message: 'ok', src: imagePath, alt: 'house' },
-        [],
-        {} as any,
-      )
-      expect(node).not.toBeNull()
-      expect(React.isValidElement(node)).toBe(true)
-    })
-
-    it('returns Text element when success but no src', () => {
-      const node = ImageShowTool.renderToolResultMessage(
-        { success: true, message: 'Displayed: house.png' },
-        [],
-        {} as any,
-      )
-      expect(node).not.toBeNull()
-      expect(React.isValidElement(node)).toBe(true)
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  prompt helper
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('prompt', () => {
-    it('describes supported formats and protocols', async () => {
-      const p = await ImageShowTool.prompt({} as any)
-      expect(p).toMatch(/png|jpeg|gif|webp/i)
-      expect(p).toMatch(/unicode|kitty|terminal/i)
-    })
-  })
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  //  checkPermissions
-  // ═══════════════════════════════════════════════════════════════════════════
-  describe('checkPermissions', () => {
-    it('always allows', async () => {
-      const r = await ImageShowTool.checkPermissions()
-      expect(r.behavior).toBe('allow')
-    })
-  })
-})

src/tools/ImageShowTool/__tests__/ImageShowTool.test.tsx

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ImageShowTool } from '../ImageShowTool';
-
-// Remote image test to verify ImageShowTool loading and rendering logic
-describe('ImageShowTool', () => {
-  it('loads and processes a remote image successfully', async () => {
-    const url = 'https://upload.wikimedia.org/wikipedia/en/7/7d/Lenna_%28test_image%29.png';
-    const result = await ImageShowTool.call({ url });
-    expect(result.data.success).toBe(true);
-    // Ensure the returned data includes image dimensions
-    expect(typeof result.data.naturalWidth).toBe('number');
-    expect(typeof result.data.naturalHeight).toBe('number');
-    // Base64 representation should be present
-    expect(typeof result.data.base64).toBe('string');
-  });
-});

src/tools/ImageShowTool/__tests__/ShowLocalImage.test.tsx

@@ -1,72 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Visual test: display a local image using ink-picture + Ink.
- *
- * Usage:
- *   bun run src/tools/ImageShowTool/__tests__/ShowLocalImage.test.tsx
- *   Press Ctrl+C to exit
- */
-
-import { Jimp } from 'jimp'
-import React, { useEffect, useState } from 'react'
-import { render, Box, Text, useApp } from 'ink'
-import Image, { InkPictureProvider } from 'src/ink-picture/index.ts'
-
-const IMAGE_PATH = '/home/yuki/Pictures/Wallpapers/3god.jpg'
-
-const CELL_WIDTH = 8
-const CELL_HEIGHT = 16
-
-function App() {
-  const { exit } = useApp()
-  const [dims, setDims] = useState<{
-    width: number
-    height: number
-    pixelWidth: number
-    pixelHeight: number
-  } | null>(null)
-  const [err, setErr] = useState(false)
-
-  useEffect(() => {
-    (async () => {
-      try {
-        const image = await Jimp.read(IMAGE_PATH)
-        const origW = image.bitmap.width
-        const origH = image.bitmap.height
-        const cols = process.stdout.columns ?? 80
-
-        const targetW_chars = Math.floor(cols * 0.6)
-        const targetW_pixels = targetW_chars * CELL_WIDTH
-        const targetH_pixels = Math.floor(targetW_pixels * (origH / origW))
-        const minH_pixels = 3 * CELL_HEIGHT
-        const finalH_pixels = Math.max(targetH_pixels, minH_pixels)
-        const targetH_chars = Math.ceil(finalH_pixels / CELL_HEIGHT)
-
-        setDims({ width: targetW_chars, height: targetH_chars, pixelWidth: targetW_pixels, pixelHeight: finalH_pixels })
-      } catch {
-        setErr(true)
-        exit()
-      }
-    })()
-  }, [exit])
-
-  useEffect(() => {
-    const handleSigint = () => exit()
-    process.on('SIGINT', handleSigint)
-    return () => process.off('SIGINT', handleSigint)
-  }, [exit])
-
-  if (err) return <Text color="red">Failed to load image</Text>
-  if (!dims) return <Text>Loading...</Text>
-
-  return (
-    <Box flexDirection="column">
-      <InkPictureProvider>
-        <Image src={IMAGE_PATH} width={dims.width} height={dims.height} pixelWidth={dims.pixelWidth} pixelHeight={dims.pixelHeight} alt="3god" />
-      </InkPictureProvider>
-    </Box>
-  )
-}
-
-const { waitUntilExit } = render(<App />)
-await waitUntilExit()

src/tools/ImageShowTool/__tests__/ShowUrlImage.test.tsx

@@ -1,72 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Visual test: display a remote image using ink-picture + Ink.
- *
- * Usage:
- *   bun run src/tools/ImageShowTool/__tests__/ShowUrlImage.test.tsx
- *   Press Ctrl+C to exit
- */
-
-import React, { useEffect, useState } from 'react'
-import { render, Box, Text, useApp } from 'ink'
-import Image, { InkPictureProvider } from 'src/ink-picture/index.ts'
-import { loadImageFromUrl } from 'src/ink-picture/utils/jimpURL.ts'
-
-const IMAGE_URL = 'https://upload.wikimedia.org/wikipedia/en/7/7d/Lenna_%28test_image%29.png'
-
-const CELL_WIDTH = 8
-const CELL_HEIGHT = 16
-
-function App() {
-  const { exit } = useApp()
-  const [dims, setDims] = useState<{
-    width: number
-    height: number
-    pixelWidth: number
-    pixelHeight: number
-  } | null>(null)
-  const [err, setErr] = useState(false)
-
-  useEffect(() => {
-    (async () => {
-      try {
-        const image = await loadImageFromUrl(IMAGE_URL)
-        const origW = image.bitmap.width
-        const origH = image.bitmap.height
-        const cols = process.stdout.columns ?? 80
-
-        const targetW_chars = Math.floor(cols * 0.6)
-        const targetW_pixels = targetW_chars * CELL_WIDTH
-        const targetH_pixels = Math.floor(targetW_pixels * (origH / origW))
-        const minH_pixels = 3 * CELL_HEIGHT
-        const finalH_pixels = Math.max(targetH_pixels, minH_pixels)
-        const targetH_chars = Math.ceil(finalH_pixels / CELL_HEIGHT)
-
-        setDims({ width: targetW_chars, height: targetH_chars, pixelWidth: targetW_pixels, pixelHeight: finalH_pixels })
-      } catch {
-        setErr(true)
-        exit()
-      }
-    })()
-  }, [exit])
-
-  useEffect(() => {
-    const handleSigint = () => exit()
-    process.on('SIGINT', handleSigint)
-    return () => process.off('SIGINT', handleSigint)
-  }, [exit])
-
-  if (err) return <Text color="red">Failed to load image: {IMAGE_URL}</Text>
-  if (!dims) return <Text>Loading...</Text>
-
-  return (
-    <Box flexDirection="column">
-      <InkPictureProvider>
-        <Image src={IMAGE_URL} width={dims.width} height={dims.height} pixelWidth={dims.pixelWidth} pixelHeight={dims.pixelHeight} alt="remote" />
-      </InkPictureProvider>
-    </Box>
-  )
-}
-
-const { waitUntilExit } = render(<App />)
-await waitUntilExit()