noupload 1.0.1 → 1.0.2

package/src/commands/image/filters.ts

@@ -1,12 +1,13 @@
 import { existsSync } from 'node:fs';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
 import { fileResult, info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
-const AVAILABLE_FILTERS = ['grayscale', 'sepia', 'blur', 'sharpen', 'negate', 'normalize'];
+const AVAILABLE_FILTERS = ['grayscale', 'sepia', 'blur', 'invert', 'normalize'];
 
 export const filters = defineCommand({
   meta: {
@@ -33,8 +34,8 @@ export const filters = defineCommand({
     intensity: {
       type: 'string',
       alias: 'i',
-      description: 'Filter intensity (for blur, sharpen)',
-      default: '3',
+      description: 'Filter intensity (for blur)',
+      default: '5',
     },
   },
   async run({ args }) {
@@ -55,40 +56,32 @@ export const filters = defineCommand({
       ensureDir(outputPath);
 
       const inputSize = getFileSize(inputPath);
-      const intensity = Number.parseFloat(args.intensity || '3');
+      const intensity = Number.parseInt(args.intensity || '5', 10);
 
       await withSpinner(
         `Applying ${filter} filter...`,
         async () => {
-          let pipeline = sharp(inputPath);
+          const image = await Jimp.read(inputPath);
 
           switch (filter) {
             case 'grayscale':
-              pipeline = pipeline.grayscale();
+              image.greyscale();
               break;
             case 'sepia':
-              // Sepia effect using recomb matrix
-              pipeline = pipeline.recomb([
-                [0.393, 0.769, 0.189],
-                [0.349, 0.686, 0.168],
-                [0.272, 0.534, 0.131],
-              ]);
+              image.sepia();
               break;
             case 'blur':
-              pipeline = pipeline.blur(intensity);
+              image.blur(intensity);
               break;
-            case 'sharpen':
-              pipeline = pipeline.sharpen(intensity);
-              break;
-            case 'negate':
-              pipeline = pipeline.negate();
+            case 'invert':
+              image.invert();
               break;
             case 'normalize':
-              pipeline = pipeline.normalize();
+              image.normalize();
               break;
           }
 
-          await pipeline.toFile(outputPath);
+          await writeImage(image, outputPath);
         },
         'Filter applied successfully'
       );

package/src/commands/image/resize.ts

@@ -1,11 +1,11 @@
-import { existsSync } from 'node:fs';
+import { existsSync, writeFileSync } from 'node:fs';
 import { defineCommand } from 'citty';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
 import { fileResult, info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
-
-type FitMode = 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+import { getMimeType, writeImage } from '../../utils/image';
 
 export const resize = defineCommand({
   meta: {
@@ -36,7 +36,7 @@ export const resize = defineCommand({
     fit: {
       type: 'string',
       alias: 'f',
-      description: 'Fit mode: cover, contain, fill, inside, outside',
+      description: 'Fit mode: cover, contain, inside (default: inside)',
       default: 'inside',
     },
     scale: {
@@ -58,15 +58,10 @@ export const resize = defineCommand({
       ensureDir(outputPath);
 
       const inputSize = getFileSize(inputPath);
-      const fit = (args.fit || 'inside') as FitMode;
-
-      // Lazy load sharp
-      const { default: sharp } = await import('sharp');
 
-      // Get original dimensions
-      const metadata = await sharp(inputPath).metadata();
-      const originalWidth = metadata.width || 0;
-      const originalHeight = metadata.height || 0;
+      const image = await Jimp.read(inputPath);
+      const originalWidth = image.width;
+      const originalHeight = image.height;
 
       let targetWidth: number | undefined;
       let targetHeight: number | undefined;
@@ -87,15 +82,23 @@ export const resize = defineCommand({
       await withSpinner(
         'Resizing image...',
         async () => {
-          await sharp(inputPath)
-            .resize(targetWidth, targetHeight, { fit, withoutEnlargement: true })
-            .toFile(outputPath);
+          // Calculate dimensions maintaining aspect ratio if only one dimension specified
+          if (targetWidth && !targetHeight) {
+            const ratio = targetWidth / originalWidth;
+            targetHeight = Math.round(originalHeight * ratio);
+          } else if (!targetWidth && targetHeight) {
+            const ratio = targetHeight / originalHeight;
+            targetWidth = Math.round(originalWidth * ratio);
+          }
+
+          image.resize({ w: targetWidth as number, h: targetHeight as number });
+          await writeImage(image, outputPath);
         },
         'Image resized successfully'
       );
 
-      const outputMetadata = await sharp(outputPath).metadata();
-      info(`${originalWidth}x${originalHeight} → ${outputMetadata.width}x${outputMetadata.height}`);
+      const outputImage = await Jimp.read(outputPath);
+      info(`${originalWidth}x${originalHeight} → ${outputImage.width}x${outputImage.height}`);
 
       fileResult(inputPath, outputPath, {
         before: inputSize,

package/src/commands/image/rotate.ts

@@ -1,10 +1,11 @@
 import { existsSync } from 'node:fs';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
 import { fileResult, info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
 export const rotate = defineCommand({
   meta: {
@@ -54,20 +55,20 @@ export const rotate = defineCommand({
       await withSpinner(
         'Rotating image...',
         async () => {
-          let pipeline = sharp(inputPath);
+          const image = await Jimp.read(inputPath);
 
           if (args.angle) {
             const angle = Number.parseInt(args.angle, 10);
-            pipeline = pipeline.rotate(angle);
+            image.rotate({ deg: angle });
           }
 
           if (args.flip === 'horizontal') {
-            pipeline = pipeline.flop();
+            image.flip({ horizontal: true, vertical: false });
           } else if (args.flip === 'vertical') {
-            pipeline = pipeline.flip();
+            image.flip({ horizontal: false, vertical: true });
           }
 
-          await pipeline.toFile(outputPath);
+          await writeImage(image, outputPath);
         },
         'Image rotated successfully'
       );

package/src/commands/image/strip-metadata.ts

@@ -1,10 +1,11 @@
 import { existsSync } from 'node:fs';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
-import { fileResult, success } from '../../utils/logger';
+import { fileResult, info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
 export const stripMetadata = defineCommand({
   meta: {
@@ -40,13 +41,16 @@ export const stripMetadata = defineCommand({
       await withSpinner(
         'Removing metadata...',
         async () => {
-          await sharp(inputPath)
-            .withMetadata({}) // Empty metadata object strips EXIF
-            .toFile(outputPath);
+          // Jimp automatically strips EXIF data when reading/writing
+          // as it only works with raw pixel data
+          const image = await Jimp.read(inputPath);
+          await writeImage(image, outputPath);
         },
         'Metadata removed successfully'
       );
 
+      info('EXIF and metadata stripped from image');
+
       fileResult(inputPath, outputPath, {
         before: inputSize,
         after: getFileSize(outputPath),

package/src/commands/image/to-base64.ts

@@ -1,10 +1,12 @@
 import { existsSync } from 'node:fs';
+import { extname } from 'node:path';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { resolvePath } from '../../utils/files';
 import { info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { getMimeType } from '../../utils/image';
 
 export const toBase64 = defineCommand({
   meta: {
@@ -39,20 +41,12 @@ export const toBase64 = defineCommand({
       await withSpinner(
         'Converting to Base64...',
         async () => {
-          const metadata = await sharp(inputPath).metadata();
-          const buffer = await sharp(inputPath).toBuffer();
-          base64String = buffer.toString('base64');
+          const image = await Jimp.read(inputPath);
+          mimeType = getMimeType(inputPath);
 
-          // Determine MIME type
-          const formatMap: Record<string, string> = {
-            jpeg: 'image/jpeg',
-            png: 'image/png',
-            webp: 'image/webp',
-            gif: 'image/gif',
-            svg: 'image/svg+xml',
-            avif: 'image/avif',
-          };
-          mimeType = formatMap[metadata.format || 'jpeg'] || 'image/jpeg';
+          // biome-ignore lint/suspicious/noExplicitAny: Jimp types are complex
+          const buffer = await (image as any).getBuffer(mimeType);
+          base64String = buffer.toString('base64');
         },
         'Conversion complete'
       );

package/src/commands/image/watermark.ts

@@ -1,27 +1,19 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { defineCommand } from 'citty';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
-import { fileResult, success } from '../../utils/logger';
+import { fileResult, info, success, warn } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
 type Position = 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
-function getGravity(position: Position): string {
-  const map: Record<Position, string> = {
-    center: 'center',
-    'top-left': 'northwest',
-    'top-right': 'northeast',
-    'bottom-left': 'southwest',
-    'bottom-right': 'southeast',
-  };
-  return map[position] || 'southeast';
-}
-
 export const watermark = defineCommand({
   meta: {
     name: 'watermark',
-    description: 'Add a text watermark to an image',
+    description: 'Add a text watermark to an image (requires a watermark image)',
   },
   args: {
     input: {
@@ -34,10 +26,10 @@ export const watermark = defineCommand({
       alias: 'o',
       description: 'Output file path',
     },
-    text: {
+    image: {
       type: 'string',
-      alias: 't',
-      description: 'Watermark text',
+      alias: 'i',
+      description: 'Watermark image file (PNG with transparency recommended)',
       required: true,
     },
     position: {
@@ -51,28 +43,27 @@ export const watermark = defineCommand({
       description: 'Opacity (0.0-1.0)',
       default: '0.5',
     },
-    size: {
+    scale: {
       type: 'string',
       alias: 's',
-      description: 'Font size',
-      default: '24',
-    },
-    color: {
-      type: 'string',
-      alias: 'c',
-      description: 'Text color (hex)',
-      default: '#ffffff',
+      description: 'Scale of watermark relative to image (0.0-1.0)',
+      default: '0.2',
     },
   },
   async run({ args }) {
     try {
       const input = requireArg(args.input, 'input');
-      const text = requireArg(args.text, 'text');
+      const watermarkImage = requireArg(args.image, 'image');
 
       const inputPath = resolvePath(input as string);
+      const watermarkPath = resolvePath(watermarkImage);
+
       if (!existsSync(inputPath)) {
         throw new FileNotFoundError(input as string);
       }
+      if (!existsSync(watermarkPath)) {
+        throw new FileNotFoundError(watermarkImage);
+      }
 
       const outputPath = generateOutputPath(inputPath, args.output, '-watermarked');
       ensureDir(outputPath);
@@ -80,50 +71,56 @@ export const watermark = defineCommand({
       const inputSize = getFileSize(inputPath);
       const position = (args.position || 'bottom-right') as Position;
       const opacity = Number.parseFloat(args.opacity || '0.5');
-      const fontSize = Number.parseInt(args.size || '24', 10);
-      const color = args.color || '#ffffff';
-
-      // Lazy load sharp
-      const { default: sharp } = await import('sharp');
+      const scale = Number.parseFloat(args.scale || '0.2');
 
       await withSpinner(
         'Adding watermark...',
         async () => {
-          // Get image dimensions
-          const metadata = await sharp(inputPath).metadata();
-          const width = metadata.width || 800;
-          const height = metadata.height || 600;
+          const image = await Jimp.read(inputPath);
+          const watermark = await Jimp.read(watermarkPath);
+
+          // Scale watermark relative to image size
+          const watermarkWidth = Math.round(image.width * scale);
+          const ratio = watermarkWidth / watermark.width;
+          const watermarkHeight = Math.round(watermark.height * ratio);
+
+          watermark.resize({ w: watermarkWidth, h: watermarkHeight });
+          watermark.opacity(opacity);
+
+          // Calculate position
+          let x: number;
+          let y: number;
+          const margin = 20;
 
-          // Create SVG text overlay
-          const svg = `
-            <svg width="${width}" height="${height}">
-              <style>
-                .watermark { 
-                  fill: ${color}; 
-                  fill-opacity: ${opacity}; 
-                  font-size: ${fontSize}px; 
-                  font-family: sans-serif;
-                  font-weight: bold;
-                }
-              </style>
-              <text 
-                x="${position.includes('right') ? width - 20 : position.includes('left') ? 20 : width / 2}" 
-                y="${position.includes('top') ? fontSize + 20 : position.includes('bottom') ? height - 20 : height / 2}"
-                text-anchor="${position.includes('right') ? 'end' : position.includes('left') ? 'start' : 'middle'}"
-                class="watermark"
-              >${text}</text>
-            </svg>
-          `;
+          switch (position) {
+            case 'top-left':
+              x = margin;
+              y = margin;
+              break;
+            case 'top-right':
+              x = image.width - watermarkWidth - margin;
+              y = margin;
+              break;
+            case 'bottom-left':
+              x = margin;
+              y = image.height - watermarkHeight - margin;
+              break;
+            case 'bottom-right':
+              x = image.width - watermarkWidth - margin;
+              y = image.height - watermarkHeight - margin;
+              break;
+            case 'center':
+              x = Math.round((image.width - watermarkWidth) / 2);
+              y = Math.round((image.height - watermarkHeight) / 2);
+              break;
+            default:
+              x = image.width - watermarkWidth - margin;
+              y = image.height - watermarkHeight - margin;
+          }
 
-          await sharp(inputPath)
-            .composite([
-              {
-                input: Buffer.from(svg),
-                // biome-ignore lint/suspicious/noExplicitAny: sharp types mismatch with lazy load
-                gravity: getGravity(position) as any,
-              },
-            ])
-            .toFile(outputPath);
+          // Composite watermark onto image
+          image.composite(watermark, x, y);
+          await writeImage(image, outputPath);
         },
         'Watermark added successfully'
       );

package/src/commands/pdf/from-images.ts

@@ -1,9 +1,10 @@
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, getFileSize, globFiles, resolvePath } from '../../utils/files';
 import { fileResult, info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { getMimeType } from '../../utils/image';
 
 export const fromImages = defineCommand({
   meta: {
@@ -59,21 +60,20 @@ export const fromImages = defineCommand({
           const pdf = await PDFDocument.create();
 
           for (const imagePath of imageFiles) {
-            const imageBuffer = await Bun.file(imagePath).arrayBuffer();
-            const imageBytes = new Uint8Array(imageBuffer);
+            const image = await Jimp.read(imagePath);
+            const mime = getMimeType(imagePath);
 
-            // Determine image type and convert if necessary
-            const metadata = await sharp(Buffer.from(imageBytes)).metadata();
             // biome-ignore lint/suspicious/noExplicitAny: complex PDFImage type from lazy load
             let embeddedImage: any;
 
-            if (metadata.format === 'png') {
-              embeddedImage = await pdf.embedPng(imageBytes);
+            if (mime === 'image/png') {
+              // biome-ignore lint/suspicious/noExplicitAny: Jimp types are complex
+              const pngBuffer = await (image as any).getBuffer('image/png');
+              embeddedImage = await pdf.embedPng(pngBuffer);
             } else {
               // Convert to JPEG for other formats
-              const jpegBuffer = await sharp(Buffer.from(imageBytes))
-                .jpeg({ quality: 90 })
-                .toBuffer();
+              // biome-ignore lint/suspicious/noExplicitAny: Jimp types are complex
+              const jpegBuffer = await (image as any).getBuffer('image/jpeg', { quality: 90 });
               embeddedImage = await pdf.embedJpg(jpegBuffer);
             }
 

package/src/commands/pdf/sign.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { defineCommand } from 'citty';
 import { PDFDocument } from 'pdf-lib';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
 import { fileResult, success } from '../../utils/logger';
@@ -76,16 +76,21 @@ export const sign = defineCommand({
           const pdfBytes = await Bun.file(inputPath).arrayBuffer();
           const pdf = await PDFDocument.load(pdfBytes);
 
-          // Process signature image
-          const signatureBuffer = await Bun.file(signaturePath).arrayBuffer();
-          const processedSignature = await sharp(Buffer.from(signatureBuffer))
-            .resize(signatureWidth)
-            .png()
-            .toBuffer();
+          // Process signature image with Jimp
+          const signatureImage = await Jimp.read(signaturePath);
+
+          // Calculate height to maintain aspect ratio
+          const ratio = signatureWidth / signatureImage.width;
+          const signatureHeight = Math.round(signatureImage.height * ratio);
+
+          signatureImage.resize({ w: signatureWidth, h: signatureHeight });
+
+          // biome-ignore lint/suspicious/noExplicitAny: Jimp types are complex
+          const processedSignature = await (signatureImage as any).getBuffer('image/png');
 
           // Embed image
-          const signatureImage = await pdf.embedPng(processedSignature);
-          const signatureDims = signatureImage.scale(1);
+          const embeddedSignature = await pdf.embedPng(processedSignature);
+          const signatureDims = embeddedSignature.scale(1);
 
           // Determine which page to sign
           const totalPages = pdf.getPageCount();
@@ -130,7 +135,7 @@ export const sign = defineCommand({
           }
 
           // Draw signature
-          page.drawImage(signatureImage, {
+          page.drawImage(embeddedSignature, {
             x,
             y,
             width: signatureDims.width,

package/src/commands/qr/scan.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { defineCommand } from 'citty';
 import jsQR from 'jsqr';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import { resolvePath } from '../../utils/files';
 import { info, success, warn } from '../../utils/logger';
@@ -47,19 +47,17 @@ export const scan = defineCommand({
       const result = await withSpinner(
         'Scanning QR code...',
         async (): Promise<ScanResult | null> => {
-          // Load image and convert to raw RGBA data
-          const image = sharp(inputPath);
-          const { width, height } = await image.metadata();
+          // Load image with Jimp
+          const image = await Jimp.read(inputPath);
+          const { width, height } = image;
 
           if (!width || !height) {
             throw new Error('Could not read image dimensions');
           }
 
-          // Convert to raw RGBA
-          const rawData = await image.ensureAlpha().raw().toBuffer();
-
-          // Create Uint8ClampedArray for jsQR
-          const data = new Uint8ClampedArray(rawData);
+          // Get raw RGBA data from Jimp
+          // Jimp bitmap.data is already in RGBA format
+          const data = new Uint8ClampedArray(image.bitmap.data);
 
           // Scan for QR code
           const qrCode = jsQR(data, width, height);

package/src/index.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { renderUsage, runMain } from 'citty';
 import { main } from './cli';
 import { hex } from './utils/colors';

package/src/utils/image.ts

@@ -0,0 +1,46 @@
+import { writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+
+/**
+ * Get MIME type from file extension
+ */
+export function getMimeType(filePath: string): string {
+  const ext = extname(filePath).toLowerCase().slice(1);
+  const mimeMap: Record<string, string> = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    bmp: 'image/bmp',
+    tiff: 'image/tiff',
+    tif: 'image/tiff',
+  };
+  return mimeMap[ext] || 'image/png';
+}
+
+/**
+ * Write a Jimp image to a file with proper MIME type detection
+ */
+export async function writeImage(
+  // biome-ignore lint/suspicious/noExplicitAny: Jimp types are overly complex
+  image: any,
+  outputPath: string,
+  options?: { quality?: number }
+): Promise<void> {
+  const mime = getMimeType(outputPath);
+
+  let buffer: Buffer;
+
+  if (mime === 'image/jpeg' && options?.quality) {
+    buffer = await image.getBuffer(mime, { quality: options.quality });
+  } else {
+    buffer = await image.getBuffer(mime);
+  }
+
+  writeFileSync(outputPath, buffer);
+}
+
+/**
+ * Supported image formats for Jimp
+ */
+export const SUPPORTED_FORMATS = ['jpg', 'jpeg', 'png', 'bmp', 'gif', 'tiff'];