noupload 1.0.0

package/src/commands/image/rotate.ts

@@ -0,0 +1,90 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+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';
+
+export const rotate = defineCommand({
+  meta: {
+    name: 'rotate',
+    description: 'Rotate or flip an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    angle: {
+      type: 'string',
+      alias: 'a',
+      description: 'Rotation angle (90, 180, 270, or any angle)',
+    },
+    flip: {
+      type: 'string',
+      alias: 'f',
+      description: 'Flip: horizontal, vertical',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+
+      if (!args.angle && !args.flip) {
+        throw new Error('Specify --angle or --flip');
+      }
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-rotated');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        'Rotating image...',
+        async () => {
+          let pipeline = sharp(inputPath);
+
+          if (args.angle) {
+            const angle = Number.parseInt(args.angle, 10);
+            pipeline = pipeline.rotate(angle);
+          }
+
+          if (args.flip === 'horizontal') {
+            pipeline = pipeline.flop();
+          } else if (args.flip === 'vertical') {
+            pipeline = pipeline.flip();
+          }
+
+          await pipeline.toFile(outputPath);
+        },
+        'Image rotated successfully'
+      );
+
+      const ops: string[] = [];
+      if (args.angle) ops.push(`Rotated ${args.angle}°`);
+      if (args.flip) ops.push(`Flipped ${args.flip}`);
+      info(ops.join(', '));
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Image rotated');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,60 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const stripMetadata = defineCommand({
+  meta: {
+    name: 'strip-metadata',
+    description: 'Remove EXIF and other metadata from an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-clean');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        'Removing metadata...',
+        async () => {
+          await sharp(inputPath)
+            .withMetadata({}) // Empty metadata object strips EXIF
+            .toFile(outputPath);
+        },
+        'Metadata removed successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Metadata removed from image');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,72 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { resolvePath } from '../../utils/files';
+import { info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const toBase64 = defineCommand({
+  meta: {
+    name: 'to-base64',
+    description: 'Convert an image to a Base64 string',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    dataUri: {
+      type: 'boolean',
+      alias: 'd',
+      description: 'Output as data URI (with prefix)',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      let base64String = '';
+      let mimeType = '';
+
+      await withSpinner(
+        'Converting to Base64...',
+        async () => {
+          const metadata = await sharp(inputPath).metadata();
+          const buffer = await sharp(inputPath).toBuffer();
+          base64String = buffer.toString('base64');
+
+          // 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';
+        },
+        'Conversion complete'
+      );
+
+      if (args.dataUri) {
+        console.log(`data:${mimeType};base64,${base64String}`);
+      } else {
+        console.log(base64String);
+      }
+
+      info(`Length: ${base64String.length} characters`);
+      success('Image converted to Base64');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/watermark.ts

@@ -0,0 +1,141 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+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',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    text: {
+      type: 'string',
+      alias: 't',
+      description: 'Watermark text',
+      required: true,
+    },
+    position: {
+      type: 'string',
+      alias: 'p',
+      description: 'Position: center, top-left, top-right, bottom-left, bottom-right',
+      default: 'bottom-right',
+    },
+    opacity: {
+      type: 'string',
+      description: 'Opacity (0.0-1.0)',
+      default: '0.5',
+    },
+    size: {
+      type: 'string',
+      alias: 's',
+      description: 'Font size',
+      default: '24',
+    },
+    color: {
+      type: 'string',
+      alias: 'c',
+      description: 'Text color (hex)',
+      default: '#ffffff',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const text = requireArg(args.text, 'text');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-watermarked');
+      ensureDir(outputPath);
+
+      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');
+
+      await withSpinner(
+        'Adding watermark...',
+        async () => {
+          // Get image dimensions
+          const metadata = await sharp(inputPath).metadata();
+          const width = metadata.width || 800;
+          const height = metadata.height || 600;
+
+          // 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>
+          `;
+
+          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);
+        },
+        'Watermark added successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Watermark added to image');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/compress.ts

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+import { detectGhostscript, getBestPdfCompressor, getInstallCommand } from '../../utils/detect';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success, warn } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+import { c } from '../../utils/style';
+
+type CompressionQuality = 'low' | 'medium' | 'high';
+
+const GS_SETTINGS: Record<CompressionQuality, string> = {
+  low: '/screen', // 72 dpi - smallest file
+  medium: '/ebook', // 150 dpi - good balance
+  high: '/printer', // 300 dpi - high quality
+};
+
+async function compressWithGhostscript(
+  input: string,
+  output: string,
+  quality: CompressionQuality
+): Promise<void> {
+  const gs = await detectGhostscript();
+  if (!gs.available || !gs.path) {
+    throw new Error('Ghostscript not found');
+  }
+
+  const gsPath = gs.path;
+
+  return new Promise((resolve, reject) => {
+    const gsProcess = spawn(gsPath, [
+      '-sDEVICE=pdfwrite',
+      '-dCompatibilityLevel=1.4',
+      `-dPDFSETTINGS=${GS_SETTINGS[quality]}`,
+      '-dNOPAUSE',
+      '-dQUIET',
+      '-dBATCH',
+      '-dDetectDuplicateImages=true',
+      '-dCompressFonts=true',
+      '-dSubsetFonts=true',
+      `-sOutputFile=${output}`,
+      input,
+    ]);
+
+    gsProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Ghostscript exited with code ${code}`));
+      }
+    });
+
+    gsProcess.on('error', reject);
+  });
+}
+
+async function compressWithPdfLib(input: string, output: string): Promise<void> {
+  const pdfBytes = await Bun.file(input).arrayBuffer();
+  const pdf = await PDFDocument.load(pdfBytes);
+
+  // Remove metadata to reduce size
+  pdf.setTitle('');
+  pdf.setAuthor('');
+  pdf.setSubject('');
+  pdf.setKeywords([]);
+  pdf.setProducer('');
+  pdf.setCreator('');
+
+  // Save with optimization
+  const compressedBytes = await pdf.save({
+    useObjectStreams: true,
+    addDefaultPage: false,
+  });
+
+  await Bun.write(output, compressedBytes);
+}
+
+export const compress = defineCommand({
+  meta: {
+    name: 'compress',
+    description: 'Compress a PDF file to reduce size',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    quality: {
+      type: 'string',
+      alias: 'q',
+      description: 'Compression quality: low, medium, high',
+      default: 'medium',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const inputPath = resolvePath(input as string);
+
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-compressed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const quality = (args.quality || 'medium') as CompressionQuality;
+
+      // Determine best compression method
+      const method = await getBestPdfCompressor();
+
+      await withSpinner(
+        `Compressing PDF (${quality} quality)...`,
+        async () => {
+          if (method === 'ghostscript') {
+            info('Using Ghostscript for optimal compression');
+            await compressWithGhostscript(inputPath, outputPath, quality);
+          } else {
+            warn('Using built-in compression (less effective)');
+            const installCmd = getInstallCommand('gs');
+            if (installCmd) {
+              console.log(
+                `  ${c.dim('Hint:')} Install Ghostscript for better compression: ${c.active(installCmd)}`
+              );
+            }
+            await compressWithPdfLib(inputPath, outputPath);
+          }
+        },
+        'PDF compressed successfully'
+      );
+
+      const outputSize = getFileSize(outputPath);
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: outputSize,
+      });
+
+      if (outputSize >= inputSize) {
+        warn('Compressed file is not smaller than original. The PDF may already be optimized.');
+      } else {
+        const savings = ((1 - outputSize / inputSize) * 100).toFixed(1);
+        success(`Reduced file size by ${savings}%`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/decrypt.ts

@@ -0,0 +1,102 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { detectQpdf, getInstallCommand } from '../../utils/detect';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success, warn } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const decrypt = defineCommand({
+  meta: {
+    name: 'decrypt',
+    description: 'Remove password protection from a PDF using qpdf',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    password: {
+      type: 'string',
+      alias: 'p',
+      description: 'Password to unlock the PDF',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const password = requireArg(args.password, 'password');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      // Check for qpdf
+      const qpdf = await detectQpdf();
+      if (!qpdf.available || !qpdf.path) {
+        warn('qpdf is required for PDF decryption');
+        const installCmd = getInstallCommand('qpdf');
+        if (installCmd) {
+          info(`Install: ${installCmd}`);
+        }
+        return;
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-decrypted');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const qpdfPath = qpdf.path;
+
+      // Build qpdf arguments for decryption
+      const qpdfArgs = ['--decrypt', `--password=${password}`, inputPath, outputPath];
+
+      await withSpinner(
+        'Decrypting PDF with qpdf...',
+        async () => {
+          return new Promise<void>((resolve, reject) => {
+            const proc = spawn(qpdfPath, qpdfArgs, {
+              stdio: ['pipe', 'pipe', 'pipe'],
+            });
+
+            let stderr = '';
+            proc.stderr?.on('data', (data) => {
+              stderr += data.toString();
+            });
+
+            proc.on('close', (code) => {
+              if (code === 0) {
+                resolve();
+              } else if (code === 2 && stderr.includes('password')) {
+                reject(new Error('Incorrect password'));
+              } else {
+                reject(new Error(`qpdf failed: ${stderr}`));
+              }
+            });
+
+            proc.on('error', reject);
+          });
+        },
+        'PDF decrypted successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('PDF password protection removed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});