noupload 1.0.0

package/src/commands/doctor.ts

@@ -0,0 +1,125 @@
+import { defineCommand } from 'citty';
+import { type ToolInfo, detectTool, getInstallCommand } from '../utils/detect';
+import { info, success, warn } from '../utils/logger';
+import { c, sym } from '../utils/style';
+
+interface ToolCheck {
+  name: string;
+  description: string;
+  requiredFor: string;
+  binary: string;
+}
+
+const TOOLS: ToolCheck[] = [
+  {
+    name: 'FFmpeg',
+    description: 'Audio/Video processing core',
+    requiredFor: 'All audio commands, video extraction',
+    binary: 'ffmpeg',
+  },
+  {
+    name: 'Ghostscript',
+    description: 'PDF processing engine',
+    requiredFor: 'High-quality PDF compression',
+    binary: 'gs',
+  },
+  {
+    name: 'QPDF',
+    description: 'PDF security tool',
+    requiredFor: 'PDF encryption and decryption',
+    binary: 'qpdf',
+  },
+  {
+    name: 'MuPDF Tools',
+    description: 'PDF rendering engine',
+    requiredFor: 'High-quality PDF-to-Image, OCR preprocessing',
+    binary: 'mutool',
+  },
+  {
+    name: 'Poppler',
+    description: 'PDF rendering library (Alternative)',
+    requiredFor: 'PDF-to-Text, Alternative PDF-to-Image',
+    binary: 'pdftotext',
+  },
+  {
+    name: 'ImageMagick',
+    description: 'Image manipulation suite',
+    requiredFor: 'Advanced image operations (fallback)',
+    binary: 'magick',
+  },
+];
+
+export const doctor = defineCommand({
+  meta: {
+    name: 'doctor',
+    description: 'Check system dependencies and environment health',
+  },
+  async run() {
+    console.log('');
+    info('NoUpload CLI Doctor');
+    console.log(c.dim('  Checking system dependencies...\n'));
+
+    let allGood = true;
+    const missing: ToolCheck[] = [];
+
+    // Check each tool
+    for (const tool of TOOLS) {
+      let result: ToolInfo;
+
+      if (tool.name === 'Ghostscript') {
+        const { detectGhostscript } = await import('../utils/detect');
+        result = await detectGhostscript();
+      } else if (tool.name === 'MuPDF Tools') {
+        const { detectMutool } = await import('../utils/detect');
+        result = await detectMutool();
+      } else if (tool.name === 'QPDF') {
+        const { detectQpdf } = await import('../utils/detect');
+        result = await detectQpdf();
+      } else if (tool.name === 'ImageMagick') {
+        const { detectImageMagick } = await import('../utils/detect');
+        result = await detectImageMagick();
+      } else {
+        result = await detectTool(tool.binary);
+      }
+
+      if (result.available) {
+        console.log(`  ${c.done(sym.done)} ${c.white(tool.name)}`);
+        console.log(`    ${c.dim('Path:')} ${result.path}`);
+        console.log(`    ${c.dim('Status:')} Installed`);
+      } else {
+        allGood = false;
+        missing.push(tool);
+        console.log(`  ${c.error(sym.error)} ${c.white(tool.name)}`);
+        console.log(`    ${c.dim('Required:')} ${tool.requiredFor}`);
+        console.log(`    ${c.dim('Status:')}   ${c.error('Missing')}`);
+      }
+      console.log('');
+    }
+
+    if (allGood) {
+      success('All systems operational! You are ready to use all features.');
+    } else {
+      warn('Some dependencies are missing. Certain commands may not work.');
+
+      console.log(`\n${c.title('Auto-Fix:')}`);
+      console.log(
+        `  Run ${c.active('noupload setup')} to install missing dependencies automatically.`
+      );
+      console.log(`  (Use ${c.dim('--yes')} for non-interactive mode)`);
+
+      console.log(`\n${c.title('Manual Installation:')}\n`);
+
+      for (const m of missing) {
+        const cmd =
+          getInstallCommand(m.binary) || getInstallCommand(m.name.toLowerCase().split(' ')[0]);
+        if (cmd) {
+          console.log(`${c.white(m.name)}:`);
+          console.log(`  ${c.active(cmd)}`);
+          console.log('');
+        }
+      }
+
+      process.exit(1);
+    }
+  },
+});

package/src/commands/image/adjust.ts

@@ -0,0 +1,129 @@
+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 adjust = defineCommand({
+  meta: {
+    name: 'adjust',
+    description: 'Adjust image brightness, contrast, and saturation',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    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',
+    },
+    contrast: {
+      type: 'string',
+      alias: 'c',
+      description: 'Contrast adjustment (-100 to 100)',
+    },
+    gamma: {
+      type: 'string',
+      alias: 'g',
+      description: 'Gamma correction (0.1 to 10)',
+    },
+  },
+  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, '-adjusted');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const adjustments: string[] = [];
+
+      await withSpinner(
+        'Adjusting image...',
+        async () => {
+          let pipeline = sharp(inputPath);
+
+          // Apply modulate for brightness, saturation, hue
+          const modulate: { brightness?: number; saturation?: number; hue?: number } = {};
+
+          if (args.brightness) {
+            modulate.brightness = Number.parseFloat(args.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);
+            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);
+        },
+        'Image adjusted successfully'
+      );
+
+      if (adjustments.length > 0) {
+        info(`Adjustments: ${adjustments.join(', ')}`);
+      }
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Image adjusted');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/border.ts

@@ -0,0 +1,94 @@
+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';
+
+function hexToRgb(hex: string): { r: number; g: number; b: 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 {
+    r: Number.parseInt(result[1], 16),
+    g: Number.parseInt(result[2], 16),
+    b: Number.parseInt(result[3], 16),
+  };
+}
+
+export const border = defineCommand({
+  meta: {
+    name: 'border',
+    description: 'Add a border to an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    size: {
+      type: 'string',
+      alias: 's',
+      description: 'Border size in pixels',
+      default: '10',
+    },
+    color: {
+      type: 'string',
+      alias: 'c',
+      description: 'Border color (hex)',
+      default: '#ffffff',
+    },
+  },
+  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, '-bordered');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const borderSize = Number.parseInt(args.size || '10', 10);
+      const color = hexToRgb(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);
+        },
+        'Border added successfully'
+      );
+
+      info(`Border: ${borderSize}px, Color: ${args.color || '#ffffff'}`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Border added to image');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,111 @@
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+import { handleError, requireArg } from '../../utils/errors';
+import {
+  ensureOutputDir,
+  getBasename,
+  getExtension,
+  getFileSize,
+  globFiles,
+  resolvePath,
+} from '../../utils/files';
+import { bulkResult, info, success } from '../../utils/logger';
+import { withProgress } from '../../utils/progress';
+
+export const bulkCompress = defineCommand({
+  meta: {
+    name: 'bulk-compress',
+    description: 'Compress multiple images',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input directory or glob pattern',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory',
+      required: true,
+    },
+    quality: {
+      type: 'string',
+      alias: 'q',
+      description: 'Quality (1-100)',
+      default: '80',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const output = requireArg(args.output, 'output');
+
+      const inputPath = resolvePath(input as string);
+      const outputDir = resolvePath(output);
+      ensureOutputDir(`${outputDir}/`);
+
+      // Find all image files
+      let pattern = inputPath;
+      if (!inputPath.includes('*')) {
+        pattern = `${inputPath}/**/*.{jpg,jpeg,png,webp,avif}`;
+      }
+
+      const files = await globFiles(pattern);
+      if (files.length === 0) {
+        throw new Error('No image files found');
+      }
+
+      info(`Found ${files.length} images`);
+
+      const quality = Number.parseInt(args.quality || '80', 10);
+      let totalSaved = 0;
+      let processed = 0;
+      let failed = 0;
+
+      await withProgress(files, 'Compressing', async (file) => {
+        try {
+          const basename = getBasename(file);
+          const ext = getExtension(file);
+          const outputPath = join(outputDir, `${basename}.${ext}`);
+
+          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 outputSize = getFileSize(outputPath);
+          totalSaved += inputSize - outputSize;
+          processed++;
+        } catch {
+          failed++;
+        }
+      });
+
+      bulkResult(processed, failed, totalSaved);
+      success(`Compressed ${processed} images`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,114 @@
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+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'];
+
+export const bulkConvert = defineCommand({
+  meta: {
+    name: 'bulk-convert',
+    description: 'Convert multiple images to a different format',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input directory or glob pattern',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory',
+      required: true,
+    },
+    format: {
+      type: 'string',
+      alias: 'f',
+      description: `Output format: ${SUPPORTED_FORMATS.join(', ')}`,
+      required: true,
+    },
+    quality: {
+      type: 'string',
+      alias: 'q',
+      description: 'Quality (1-100)',
+      default: '85',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const output = requireArg(args.output, 'output');
+      const format = requireArg(args.format, 'format').toLowerCase();
+
+      if (!SUPPORTED_FORMATS.includes(format)) {
+        throw new Error(`Unsupported format: ${format}`);
+      }
+
+      const inputPath = resolvePath(input as string);
+      const outputDir = resolvePath(output);
+      ensureOutputDir(`${outputDir}/`);
+
+      // Find all image files
+      let pattern = inputPath;
+      if (!inputPath.includes('*')) {
+        pattern = `${inputPath}/**/*.{jpg,jpeg,png,webp,avif,gif,tiff,heic}`;
+      }
+
+      const files = await globFiles(pattern);
+      if (files.length === 0) {
+        throw new Error('No image files found');
+      }
+
+      info(`Found ${files.length} images`);
+
+      const quality = Number.parseInt(args.quality || '85', 10);
+      let processed = 0;
+      let failed = 0;
+
+      await withProgress(files, `Converting to ${format.toUpperCase()}`, async (file) => {
+        try {
+          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);
+          processed++;
+        } catch {
+          failed++;
+        }
+      });
+
+      bulkResult(processed, failed);
+      success(`Converted ${processed} images to ${format.toUpperCase()}`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,112 @@
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+import { handleError, requireArg } from '../../utils/errors';
+import {
+  ensureOutputDir,
+  getBasename,
+  getExtension,
+  globFiles,
+  resolvePath,
+} from '../../utils/files';
+import { bulkResult, info, success } from '../../utils/logger';
+import { withProgress } from '../../utils/progress';
+
+export const bulkResize = defineCommand({
+  meta: {
+    name: 'bulk-resize',
+    description: 'Resize multiple images',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input directory or glob pattern',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory',
+      required: true,
+    },
+    width: {
+      type: 'string',
+      alias: 'w',
+      description: 'Target width in pixels',
+    },
+    height: {
+      type: 'string',
+      alias: 'h',
+      description: 'Target height in pixels',
+    },
+    scale: {
+      type: 'string',
+      alias: 's',
+      description: 'Scale factor (e.g., 0.5)',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const output = requireArg(args.output, 'output');
+
+      if (!args.width && !args.height && !args.scale) {
+        throw new Error('Specify --width, --height, or --scale');
+      }
+
+      const inputPath = resolvePath(input as string);
+      const outputDir = resolvePath(output);
+      ensureOutputDir(`${outputDir}/`);
+
+      // Find all image files
+      let pattern = inputPath;
+      if (!inputPath.includes('*')) {
+        pattern = `${inputPath}/**/*.{jpg,jpeg,png,webp,avif,gif}`;
+      }
+
+      const files = await globFiles(pattern);
+      if (files.length === 0) {
+        throw new Error('No image files found');
+      }
+
+      info(`Found ${files.length} images`);
+
+      let processed = 0;
+      let failed = 0;
+
+      await withProgress(files, 'Resizing', async (file) => {
+        try {
+          const basename = getBasename(file);
+          const ext = getExtension(file);
+          const outputPath = join(outputDir, `${basename}.${ext}`);
+
+          let targetWidth: number | undefined;
+          let targetHeight: number | undefined;
+
+          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);
+          } else {
+            targetWidth = args.width ? Number.parseInt(args.width, 10) : undefined;
+            targetHeight = args.height ? Number.parseInt(args.height, 10) : undefined;
+          }
+
+          await sharp(file)
+            .resize(targetWidth, targetHeight, { fit: 'inside', withoutEnlargement: true })
+            .toFile(outputPath);
+
+          processed++;
+        } catch {
+          failed++;
+        }
+      });
+
+      bulkResult(processed, failed);
+      success(`Resized ${processed} images`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});