noupload 1.0.1 → 1.0.2

package/package.json

@@ -1,33 +1,22 @@
 {
   "name": "noupload",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Privacy-first CLI for PDF, Image, Audio, and QR operations - all processed locally",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
     "noupload": "./dist/index.js"
   },
-  "pkg": {
-    "assets": [
-      "node_modules/sharp/**/*"
-    ],
-    "targets": [
-      "node18-linux-x64",
-      "node18-linux-arm64",
-      "node18-macos-x64",
-      "node18-macos-arm64",
-      "node18-win-x64"
-    ]
-  },
   "scripts": {
     "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target bun --minify",
+    "build": "bun build src/index.ts --outfile dist/index.js --target node",
     "build:compile": "bun build src/index.ts --compile --outfile dist/noupload",
     "build:all": "bun run scripts/build.ts",
     "test": "bun test",
     "lint": "bunx @biomejs/biome check .",
     "format": "bunx @biomejs/biome format --write .",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
   },
   "dependencies": {
     "citty": "^0.1.6",
@@ -35,25 +24,41 @@
     "consola": "^3.2.3",
     "filesize": "^10.1.6",
     "fluent-ffmpeg": "^2.1.3",
+    "jimp": "^1.6.0",
     "jsqr": "^1.4.0",
     "ora": "^8.1.1",
     "pdf-lib": "^1.17.1",
     "qrcode": "^1.5.4",
-    "sharp": "^0.33.5",
     "tesseract.js": "^5.1.1"
   },
   "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
     "@types/bun": "latest",
     "@types/cli-progress": "^3.11.6",
     "@types/fluent-ffmpeg": "^2.1.27",
     "@types/qrcode": "^1.5.5",
     "@types/which": "^3.0.4",
-    "@biomejs/biome": "^1.9.4",
     "typescript": "^5.7.2"
   },
   "engines": {
-    "bun": ">=1.0.0"
+    "bun": ">=1.0.0",
+    "node": ">=18.0.0"
   },
   "license": "MIT",
-  "keywords": ["pdf", "image", "audio", "qr", "cli", "privacy", "offline", "compress", "convert", "ocr"]
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shockz09/nouploadcli.git"
+  },
+  "keywords": [
+    "pdf",
+    "image",
+    "audio",
+    "qr",
+    "cli",
+    "privacy",
+    "offline",
+    "compress",
+    "convert",
+    "ocr"
+  ]
 }

package/src/commands/image/adjust.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 adjust = defineCommand({
   meta: {
@@ -25,27 +26,12 @@ export const adjust = defineCommand({
     brightness: {
       type: 'string',
       alias: 'b',
-      description: 'Brightness multiplier (1.0 = no change)',
-    },
-    saturation: {
-      type: 'string',
-      alias: 's',
-      description: 'Saturation multiplier (1.0 = no change)',
-    },
-    hue: {
-      type: 'string',
-      alias: 'h',
-      description: 'Hue rotation in degrees',
+      description: 'Brightness adjustment (-1.0 to 1.0, 0 = no change)',
     },
     contrast: {
       type: 'string',
       alias: 'c',
-      description: 'Contrast adjustment (-100 to 100)',
-    },
-    gamma: {
-      type: 'string',
-      alias: 'g',
-      description: 'Gamma correction (0.1 to 10)',
+      description: 'Contrast adjustment (-1.0 to 1.0, 0 = no change)',
     },
   },
   async run({ args }) {
@@ -57,6 +43,10 @@ export const adjust = defineCommand({
         throw new FileNotFoundError(input as string);
       }
 
+      if (!args.brightness && !args.contrast) {
+        throw new Error('Specify --brightness or --contrast');
+      }
+
       const outputPath = generateOutputPath(inputPath, args.output, '-adjusted');
       ensureDir(outputPath);
 
@@ -66,48 +56,21 @@ export const adjust = defineCommand({
       await withSpinner(
         'Adjusting image...',
         async () => {
-          let pipeline = sharp(inputPath);
-
-          // Apply modulate for brightness, saturation, hue
-          const modulate: { brightness?: number; saturation?: number; hue?: number } = {};
+          const image = await Jimp.read(inputPath);
 
           if (args.brightness) {
-            modulate.brightness = Number.parseFloat(args.brightness);
+            const brightness = Number.parseFloat(args.brightness);
+            image.brightness(brightness);
             adjustments.push(`brightness: ${args.brightness}`);
           }
 
-          if (args.saturation) {
-            modulate.saturation = Number.parseFloat(args.saturation);
-            adjustments.push(`saturation: ${args.saturation}`);
-          }
-
-          if (args.hue) {
-            modulate.hue = Number.parseInt(args.hue, 10);
-            adjustments.push(`hue: ${args.hue}°`);
-          }
-
-          if (Object.keys(modulate).length > 0) {
-            pipeline = pipeline.modulate(modulate);
-          }
-
-          // Apply linear for contrast
           if (args.contrast) {
             const contrast = Number.parseFloat(args.contrast);
-            // Convert -100 to 100 range to multiplier
-            const multiplier = 1 + contrast / 100;
-            const offset = 128 * (1 - multiplier);
-            pipeline = pipeline.linear(multiplier, offset);
+            image.contrast(contrast);
             adjustments.push(`contrast: ${args.contrast}`);
           }
 
-          // Apply gamma
-          if (args.gamma) {
-            const gamma = Number.parseFloat(args.gamma);
-            pipeline = pipeline.gamma(gamma);
-            adjustments.push(`gamma: ${args.gamma}`);
-          }
-
-          await pipeline.toFile(outputPath);
+          await writeImage(image, outputPath);
         },
         'Image adjusted successfully'
       );

package/src/commands/image/border.ts

@@ -1,21 +1,22 @@
 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';
 
-function hexToRgb(hex: string): { r: number; g: number; b: number } {
+function hexToRgba(hex: string): number {
   const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
   if (!result) {
-    return { r: 0, g: 0, b: 0 };
+    return 0xffffffff; // White default
   }
-  return {
-    r: Number.parseInt(result[1], 16),
-    g: Number.parseInt(result[2], 16),
-    b: Number.parseInt(result[3], 16),
-  };
+  const r = Number.parseInt(result[1], 16);
+  const g = Number.parseInt(result[2], 16);
+  const b = Number.parseInt(result[3], 16);
+  // Jimp uses RGBA format: 0xRRGGBBAA
+  return ((r << 24) | (g << 16) | (b << 8) | 0xff) >>> 0;
 }
 
 export const border = defineCommand({
@@ -61,20 +62,23 @@ export const border = defineCommand({
 
       const inputSize = getFileSize(inputPath);
       const borderSize = Number.parseInt(args.size || '10', 10);
-      const color = hexToRgb(args.color || '#ffffff');
+      const borderColor = hexToRgba(args.color || '#ffffff');
 
       await withSpinner(
         `Adding ${borderSize}px border...`,
         async () => {
-          await sharp(inputPath)
-            .extend({
-              top: borderSize,
-              bottom: borderSize,
-              left: borderSize,
-              right: borderSize,
-              background: color,
-            })
-            .toFile(outputPath);
+          const sourceImage = await Jimp.read(inputPath);
+
+          // Create new image with border
+          const newWidth = sourceImage.width + borderSize * 2;
+          const newHeight = sourceImage.height + borderSize * 2;
+
+          const newImage = new Jimp({ width: newWidth, height: newHeight, color: borderColor });
+
+          // Composite original image onto the new image with border offset
+          newImage.composite(sourceImage, borderSize, borderSize);
+
+          await writeImage(newImage, outputPath);
         },
         'Border added successfully'
       );

package/src/commands/image/bulk-compress.ts

@@ -1,6 +1,6 @@
 import { join } from 'node:path';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { handleError, requireArg } from '../../utils/errors';
 import {
   ensureOutputDir,
@@ -12,6 +12,7 @@ import {
 } from '../../utils/files';
 import { bulkResult, info, success } from '../../utils/logger';
 import { withProgress } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
 export const bulkCompress = defineCommand({
   meta: {
@@ -49,7 +50,7 @@ export const bulkCompress = defineCommand({
       // Find all image files
       let pattern = inputPath;
       if (!inputPath.includes('*')) {
-        pattern = `${inputPath}/**/*.{jpg,jpeg,png,webp,avif}`;
+        pattern = `${inputPath}/**/*.{jpg,jpeg,png,bmp,gif,tiff}`;
       }
 
       const files = await globFiles(pattern);
@@ -72,27 +73,8 @@ export const bulkCompress = defineCommand({
 
           const inputSize = getFileSize(file);
 
-          let pipeline = sharp(file);
-
-          switch (ext) {
-            case 'jpg':
-            case 'jpeg':
-              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-              break;
-            case 'png':
-              pipeline = pipeline.png({ quality, compressionLevel: 9 });
-              break;
-            case 'webp':
-              pipeline = pipeline.webp({ quality });
-              break;
-            case 'avif':
-              pipeline = pipeline.avif({ quality });
-              break;
-            default:
-              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-          }
-
-          await pipeline.toFile(outputPath);
+          const image = await Jimp.read(file);
+          await writeImage(image, outputPath, { quality });
 
           const outputSize = getFileSize(outputPath);
           totalSaved += inputSize - outputSize;

package/src/commands/image/bulk-convert.ts

@@ -1,12 +1,11 @@
 import { join } from 'node:path';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { handleError, requireArg } from '../../utils/errors';
 import { ensureOutputDir, getBasename, globFiles, resolvePath } from '../../utils/files';
 import { bulkResult, info, success } from '../../utils/logger';
 import { withProgress } from '../../utils/progress';
-
-const SUPPORTED_FORMATS = ['jpg', 'jpeg', 'png', 'webp', 'avif', 'gif', 'tiff'];
+import { SUPPORTED_FORMATS, writeImage } from '../../utils/image';
 
 export const bulkConvert = defineCommand({
   meta: {
@@ -45,7 +44,9 @@ export const bulkConvert = defineCommand({
       const format = requireArg(args.format, 'format').toLowerCase();
 
       if (!SUPPORTED_FORMATS.includes(format)) {
-        throw new Error(`Unsupported format: ${format}`);
+        throw new Error(
+          `Unsupported format: ${format}. Supported: ${SUPPORTED_FORMATS.join(', ')}`
+        );
       }
 
       const inputPath = resolvePath(input as string);
@@ -55,7 +56,7 @@ export const bulkConvert = defineCommand({
       // Find all image files
       let pattern = inputPath;
       if (!inputPath.includes('*')) {
-        pattern = `${inputPath}/**/*.{jpg,jpeg,png,webp,avif,gif,tiff,heic}`;
+        pattern = `${inputPath}/**/*.{jpg,jpeg,png,bmp,gif,tiff}`;
       }
 
       const files = await globFiles(pattern);
@@ -74,31 +75,8 @@ export const bulkConvert = defineCommand({
           const basename = getBasename(file);
           const outputPath = join(outputDir, `${basename}.${format}`);
 
-          let pipeline = sharp(file);
-
-          switch (format) {
-            case 'jpg':
-            case 'jpeg':
-              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-              break;
-            case 'png':
-              pipeline = pipeline.png({ quality });
-              break;
-            case 'webp':
-              pipeline = pipeline.webp({ quality });
-              break;
-            case 'avif':
-              pipeline = pipeline.avif({ quality });
-              break;
-            case 'gif':
-              pipeline = pipeline.gif();
-              break;
-            case 'tiff':
-              pipeline = pipeline.tiff({ quality });
-              break;
-          }
-
-          await pipeline.toFile(outputPath);
+          const image = await Jimp.read(file);
+          await writeImage(image, outputPath, { quality });
           processed++;
         } catch {
           failed++;

package/src/commands/image/bulk-resize.ts

@@ -1,6 +1,6 @@
 import { join } from 'node:path';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { handleError, requireArg } from '../../utils/errors';
 import {
   ensureOutputDir,
@@ -11,6 +11,7 @@ import {
 } from '../../utils/files';
 import { bulkResult, info, success } from '../../utils/logger';
 import { withProgress } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
 export const bulkResize = defineCommand({
   meta: {
@@ -61,7 +62,7 @@ export const bulkResize = defineCommand({
       // Find all image files
       let pattern = inputPath;
       if (!inputPath.includes('*')) {
-        pattern = `${inputPath}/**/*.{jpg,jpeg,png,webp,avif,gif}`;
+        pattern = `${inputPath}/**/*.{jpg,jpeg,png,bmp,gif,tiff}`;
       }
 
       const files = await globFiles(pattern);
@@ -80,22 +81,30 @@ export const bulkResize = defineCommand({
           const ext = getExtension(file);
           const outputPath = join(outputDir, `${basename}.${ext}`);
 
-          let targetWidth: number | undefined;
-          let targetHeight: number | undefined;
+          const image = await Jimp.read(file);
+          let targetWidth: number;
+          let targetHeight: number;
 
           if (args.scale) {
-            const metadata = await sharp(file).metadata();
             const scale = Number.parseFloat(args.scale);
-            targetWidth = Math.round((metadata.width || 0) * scale);
-            targetHeight = Math.round((metadata.height || 0) * scale);
+            targetWidth = Math.round(image.width * scale);
+            targetHeight = Math.round(image.height * scale);
           } else {
-            targetWidth = args.width ? Number.parseInt(args.width, 10) : undefined;
-            targetHeight = args.height ? Number.parseInt(args.height, 10) : undefined;
+            targetWidth = args.width ? Number.parseInt(args.width, 10) : image.width;
+            targetHeight = args.height ? Number.parseInt(args.height, 10) : image.height;
+
+            // Maintain aspect ratio if only one dimension specified
+            if (args.width && !args.height) {
+              const ratio = targetWidth / image.width;
+              targetHeight = Math.round(image.height * ratio);
+            } else if (!args.width && args.height) {
+              const ratio = targetHeight / image.height;
+              targetWidth = Math.round(image.width * ratio);
+            }
           }
 
-          await sharp(file)
-            .resize(targetWidth, targetHeight, { fit: 'inside', withoutEnlargement: true })
-            .toFile(outputPath);
+          image.resize({ w: targetWidth, h: targetHeight });
+          await writeImage(image, outputPath);
 
           processed++;
         } catch {

package/src/commands/image/compress.ts

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs';
 import { defineCommand } from 'citty';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
 import {
   ensureDir,
@@ -10,6 +11,7 @@ import {
 } from '../../utils/files';
 import { fileResult, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
+import { writeImage } from '../../utils/image';
 
 export const compressCmd = defineCommand({
   meta: {
@@ -48,35 +50,12 @@ export const compressCmd = defineCommand({
 
       const inputSize = getFileSize(inputPath);
       const quality = Number.parseInt(args.quality || '80', 10);
-      const ext = getExtension(inputPath);
-
-      // Lazy load sharp
-      const { default: sharp } = await import('sharp');
 
       await withSpinner(
         `Compressing image (quality: ${quality})...`,
         async () => {
-          let pipeline = sharp(inputPath);
-
-          switch (ext) {
-            case 'jpg':
-            case 'jpeg':
-              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-              break;
-            case 'png':
-              pipeline = pipeline.png({ quality, compressionLevel: 9 });
-              break;
-            case 'webp':
-              pipeline = pipeline.webp({ quality });
-              break;
-            case 'avif':
-              pipeline = pipeline.avif({ quality });
-              break;
-            default:
-              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-          }
-
-          await pipeline.toFile(outputPath);
+          const image = await Jimp.read(inputPath);
+          await writeImage(image, outputPath, { quality });
         },
         'Image compressed successfully'
       );

package/src/commands/image/convert.ts

@@ -1,6 +1,6 @@
 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,
@@ -11,8 +11,7 @@ import {
 } from '../../utils/files';
 import { fileResult, info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
-
-const SUPPORTED_FORMATS = ['jpg', 'jpeg', 'png', 'webp', 'avif', 'gif', 'tiff', 'heif'];
+import { SUPPORTED_FORMATS, writeImage } from '../../utils/image';
 
 export const convert = defineCommand({
   meta: {
@@ -39,7 +38,7 @@ export const convert = defineCommand({
     quality: {
       type: 'string',
       alias: 'q',
-      description: 'Quality (1-100)',
+      description: 'Quality (1-100, for JPEG)',
       default: '85',
     },
   },
@@ -69,34 +68,8 @@ export const convert = defineCommand({
       await withSpinner(
         `Converting ${inputExt.toUpperCase()} to ${format.toUpperCase()}...`,
         async () => {
-          let pipeline = sharp(inputPath);
-
-          switch (format) {
-            case 'jpg':
-            case 'jpeg':
-              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-              break;
-            case 'png':
-              pipeline = pipeline.png({ quality });
-              break;
-            case 'webp':
-              pipeline = pipeline.webp({ quality });
-              break;
-            case 'avif':
-              pipeline = pipeline.avif({ quality });
-              break;
-            case 'gif':
-              pipeline = pipeline.gif();
-              break;
-            case 'tiff':
-              pipeline = pipeline.tiff({ quality });
-              break;
-            case 'heif':
-              pipeline = pipeline.heif({ quality });
-              break;
-          }
-
-          await pipeline.toFile(outputPath);
+          const image = await Jimp.read(inputPath);
+          await writeImage(image, outputPath, { quality });
         },
         'Image converted successfully'
       );

package/src/commands/image/crop.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 crop = defineCommand({
   meta: {
@@ -65,18 +66,18 @@ export const crop = defineCommand({
       const cropWidth = Number.parseInt(width, 10);
       const cropHeight = Number.parseInt(height, 10);
 
+      const image = await Jimp.read(inputPath);
+
       // Validate crop area
-      const metadata = await sharp(inputPath).metadata();
-      if (left + cropWidth > (metadata.width || 0) || top + cropHeight > (metadata.height || 0)) {
+      if (left + cropWidth > image.width || top + cropHeight > image.height) {
         throw new Error('Crop area exceeds image boundaries');
       }
 
       await withSpinner(
         `Cropping image (${cropWidth}x${cropHeight} at ${left},${top})...`,
         async () => {
-          await sharp(inputPath)
-            .extract({ left, top, width: cropWidth, height: cropHeight })
-            .toFile(outputPath);
+          image.crop({ x: left, y: top, w: cropWidth, h: cropHeight });
+          await writeImage(image, outputPath);
         },
         'Image cropped successfully'
       );

package/src/commands/image/favicon.ts

@@ -1,12 +1,13 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { defineCommand } from 'citty';
-import sharp from 'sharp';
+import { Jimp } from 'jimp';
 import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
-import { ensureOutputDir, getBasename, resolvePath } from '../../utils/files';
+import { ensureOutputDir, resolvePath } from '../../utils/files';
 import { info, success } from '../../utils/logger';
 import { withSpinner } from '../../utils/progress';
 import { c } from '../../utils/style';
+import { writeImage } from '../../utils/image';
 
 const FAVICON_SIZES = [16, 32, 48, 64, 128, 180, 192, 512];
 
@@ -44,26 +45,26 @@ export const favicon = defineCommand({
       await withSpinner(
         `Generating ${FAVICON_SIZES.length} favicon sizes...`,
         async () => {
+          const sourceImage = await Jimp.read(inputPath);
+
           for (const size of FAVICON_SIZES) {
+            const image = sourceImage.clone();
+            // Use contain to fit within size while maintaining aspect ratio
+            image.contain({ w: size, h: size });
+
             const outputPath = join(outputDir, `favicon-${size}x${size}.png`);
-            await sharp(inputPath)
-              .resize(size, size, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-              .png()
-              .toFile(outputPath);
+            await writeImage(image, outputPath);
           }
 
           // Also generate apple-touch-icon
-          await sharp(inputPath)
-            .resize(180, 180, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-            .png()
-            .toFile(join(outputDir, 'apple-touch-icon.png'));
+          const appleTouchImage = sourceImage.clone();
+          appleTouchImage.contain({ w: 180, h: 180 });
+          await writeImage(appleTouchImage, join(outputDir, 'apple-touch-icon.png'));
 
-          // Generate favicon.ico (16x16 and 32x32 combined would need ICO format)
-          // For simplicity, we'll just create a 32x32 PNG named favicon.png
-          await sharp(inputPath)
-            .resize(32, 32, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-            .png()
-            .toFile(join(outputDir, 'favicon.png'));
+          // Generate favicon.png (32x32)
+          const faviconImage = sourceImage.clone();
+          faviconImage.contain({ w: 32, h: 32 });
+          await writeImage(faviconImage, join(outputDir, 'favicon.png'));
         },
         'Favicons generated successfully'
       );