noupload 1.0.0

package/src/commands/pdf/delete-pages.ts

@@ -0,0 +1,112 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+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 parsePages(pagesStr: string, totalPages: number): Set<number> {
+  const pages: Set<number> = new Set();
+  const parts = pagesStr.split(',').map((s) => s.trim());
+
+  for (const part of parts) {
+    if (part.includes('-')) {
+      const [start, end] = part.split('-').map((s) => Number.parseInt(s.trim(), 10));
+      for (let i = Math.max(1, start); i <= Math.min(totalPages, end); i++) {
+        pages.add(i - 1);
+      }
+    } else {
+      const page = Number.parseInt(part, 10);
+      if (page >= 1 && page <= totalPages) {
+        pages.add(page - 1);
+      }
+    }
+  }
+
+  return pages;
+}
+
+export const deletePages = defineCommand({
+  meta: {
+    name: 'delete-pages',
+    description: 'Remove specific pages from a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    pages: {
+      type: 'string',
+      alias: 'p',
+      description: 'Pages to delete (e.g., "2,4,6" or "5-10")',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const pages = requireArg(args.pages, 'pages');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-trimmed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        'Deleting pages...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const sourcePdf = await PDFDocument.load(pdfBytes);
+          const newPdf = await PDFDocument.create();
+
+          const totalPages = sourcePdf.getPageCount();
+          const pagesToDelete = parsePages(pages, totalPages);
+
+          // Get pages to keep (all except deleted)
+          const pagesToKeep: number[] = [];
+          for (let i = 0; i < totalPages; i++) {
+            if (!pagesToDelete.has(i)) {
+              pagesToKeep.push(i);
+            }
+          }
+
+          if (pagesToKeep.length === 0) {
+            throw new Error('Cannot delete all pages from a PDF');
+          }
+
+          const copiedPages = await newPdf.copyPages(sourcePdf, pagesToKeep);
+          for (const page of copiedPages) {
+            newPdf.addPage(page);
+          }
+
+          const trimmedBytes = await newPdf.save();
+          await Bun.write(outputPath, trimmedBytes);
+        },
+        'Pages deleted successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      info(`Deleted pages: ${pages}`);
+      success('PDF pages deleted');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/duplicate.ts

@@ -0,0 +1,119 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+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 parsePages(pagesStr: string, totalPages: number): number[] {
+  const pages: Set<number> = new Set();
+  const parts = pagesStr.split(',').map((s) => s.trim());
+
+  for (const part of parts) {
+    if (part.includes('-')) {
+      const [start, end] = part.split('-').map((s) => Number.parseInt(s.trim(), 10));
+      for (let i = Math.max(1, start); i <= Math.min(totalPages, end); i++) {
+        pages.add(i - 1);
+      }
+    } else {
+      const page = Number.parseInt(part, 10);
+      if (page >= 1 && page <= totalPages) {
+        pages.add(page - 1);
+      }
+    }
+  }
+
+  return Array.from(pages);
+}
+
+export const duplicate = defineCommand({
+  meta: {
+    name: 'duplicate',
+    description: 'Duplicate specific pages in a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    pages: {
+      type: 'string',
+      alias: 'p',
+      description: 'Pages to duplicate (e.g., "1,3,5" or "1-5")',
+      required: true,
+    },
+    times: {
+      type: 'string',
+      alias: 't',
+      description: 'Number of times to duplicate',
+      default: '1',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const pages = requireArg(args.pages, 'pages');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-duplicated');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const times = Number.parseInt(args.times || '1', 10);
+
+      await withSpinner(
+        'Duplicating pages...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const sourcePdf = await PDFDocument.load(pdfBytes);
+          const newPdf = await PDFDocument.create();
+
+          const totalPages = sourcePdf.getPageCount();
+          const pagesToDuplicate = parsePages(pages, totalPages);
+
+          // First, copy all original pages
+          const allPages = await newPdf.copyPages(
+            sourcePdf,
+            Array.from({ length: totalPages }, (_, i) => i)
+          );
+          for (const page of allPages) {
+            newPdf.addPage(page);
+          }
+
+          // Then, add duplicates at the end
+          for (let i = 0; i < times; i++) {
+            const duplicates = await newPdf.copyPages(sourcePdf, pagesToDuplicate);
+            for (const page of duplicates) {
+              newPdf.addPage(page);
+            }
+          }
+
+          const duplicatedBytes = await newPdf.save();
+          await Bun.write(outputPath, duplicatedBytes);
+        },
+        'Pages duplicated successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      info(`Duplicated pages ${pages} ${times} time(s)`);
+      success('PDF pages duplicated');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/encrypt.ts

@@ -0,0 +1,161 @@
+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 encrypt = defineCommand({
+  meta: {
+    name: 'encrypt',
+    description: 'Add password protection to 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: 'User password (required to open the PDF)',
+      required: true,
+    },
+    ownerPassword: {
+      type: 'string',
+      alias: 'O',
+      description: 'Owner password (for editing permissions, defaults to user password)',
+    },
+    keyLength: {
+      type: 'string',
+      alias: 'k',
+      description: 'Encryption key length: 40, 128, 256 (default: 256)',
+      default: '256',
+    },
+    print: {
+      type: 'string',
+      description: 'Print permission: none, low, full (default: full)',
+      default: 'full',
+    },
+    modify: {
+      type: 'string',
+      description: 'Modify permission: none, assembly, form, annotate, all (default: none)',
+      default: 'none',
+    },
+    extract: {
+      type: 'boolean',
+      description: 'Allow text/graphics extraction (default: false)',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const userPassword = requireArg(args.password, 'password');
+      const ownerPassword = args.ownerPassword || userPassword;
+
+      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 encryption');
+        const installCmd = getInstallCommand('qpdf');
+        if (installCmd) {
+          info(`Install: ${installCmd}`);
+        }
+        return;
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-encrypted');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const keyLength = args.keyLength || '256';
+
+      // Build qpdf arguments
+      const qpdfArgs = [
+        '--encrypt',
+        userPassword,
+        ownerPassword,
+        keyLength,
+        '--',
+        inputPath,
+        outputPath,
+      ];
+
+      // Add permission flags for 256-bit encryption
+      if (keyLength === '256' || keyLength === '128') {
+        // Print permission
+        if (args.print === 'none') {
+          qpdfArgs.splice(4, 0, '--print=none');
+        } else if (args.print === 'low') {
+          qpdfArgs.splice(4, 0, '--print=low');
+        }
+        // Modify permission
+        if (args.modify && args.modify !== 'all') {
+          qpdfArgs.splice(4, 0, `--modify=${args.modify}`);
+        }
+        // Extract permission
+        if (!args.extract) {
+          qpdfArgs.splice(4, 0, '--extract=n');
+        }
+      }
+
+      const qpdfPath = qpdf.path;
+
+      await withSpinner(
+        'Encrypting 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 {
+                reject(new Error(`qpdf failed: ${stderr}`));
+              }
+            });
+
+            proc.on('error', reject);
+          });
+        },
+        'PDF encrypted successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      info(`Encryption: AES-${keyLength}`);
+      info(`User password: ${userPassword.replace(/./g, '*')}`);
+      if (args.ownerPassword) {
+        info(`Owner password: ${ownerPassword.replace(/./g, '*')}`);
+      }
+
+      success('PDF encrypted with password protection');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,104 @@
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+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';
+
+export const fromImages = defineCommand({
+  meta: {
+    name: 'from-images',
+    description: 'Create a PDF from images',
+  },
+  args: {
+    images: {
+      type: 'positional',
+      description: 'Image files or glob pattern',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output PDF file',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const images = requireArg(args.images, 'images');
+      const output = requireArg(args.output, 'output');
+
+      // Get image files
+      const files = args._ as string[];
+      let imageFiles: string[] = [];
+
+      if (files && files.length > 0) {
+        imageFiles = files.map(resolvePath);
+      } else {
+        // Try as glob pattern
+        imageFiles = await globFiles(images as string);
+      }
+
+      if (imageFiles.length === 0) {
+        throw new Error('No image files found');
+      }
+
+      // Sort files naturally
+      imageFiles.sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+
+      const outputPath = resolvePath(output);
+      ensureDir(outputPath);
+
+      info(`Found ${imageFiles.length} images`);
+
+      const { PDFDocument } = await import('pdf-lib');
+
+      await withSpinner(
+        `Creating PDF from ${imageFiles.length} images...`,
+        async () => {
+          const pdf = await PDFDocument.create();
+
+          for (const imagePath of imageFiles) {
+            const imageBuffer = await Bun.file(imagePath).arrayBuffer();
+            const imageBytes = new Uint8Array(imageBuffer);
+
+            // 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);
+            } else {
+              // Convert to JPEG for other formats
+              const jpegBuffer = await sharp(Buffer.from(imageBytes))
+                .jpeg({ quality: 90 })
+                .toBuffer();
+              embeddedImage = await pdf.embedJpg(jpegBuffer);
+            }
+
+            // Create page with image dimensions
+            const page = pdf.addPage([embeddedImage.width, embeddedImage.height]);
+            page.drawImage(embeddedImage, {
+              x: 0,
+              y: 0,
+              width: embeddedImage.width,
+              height: embeddedImage.height,
+            });
+          }
+
+          const pdfBytes = await pdf.save();
+          await Bun.write(outputPath, pdfBytes);
+        },
+        'PDF created successfully'
+      );
+
+      const outputSize = getFileSize(outputPath);
+      fileResult(`${imageFiles.length} images`, outputPath, { before: 0, after: outputSize });
+
+      success(`Created PDF with ${imageFiles.length} pages`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/index.ts

@@ -0,0 +1,55 @@
+import { defineCommand } from 'citty';
+import { compress } from './compress';
+import { decrypt } from './decrypt';
+import { deletePages } from './delete-pages';
+import { duplicate } from './duplicate';
+import { encrypt } from './encrypt';
+import { fromImages } from './from-images';
+import { merge } from './merge';
+import { ocr } from './ocr';
+import { organize } from './organize';
+import { pageNumbers } from './page-numbers';
+import { reverse } from './reverse';
+import { rotate } from './rotate';
+import { sanitize } from './sanitize';
+import { sign } from './sign';
+import { split } from './split';
+import { toImages } from './to-images';
+import { toText } from './to-text';
+import { watermark } from './watermark';
+
+export const pdf = defineCommand({
+  meta: {
+    name: 'pdf',
+    description: 'PDF manipulation tools',
+  },
+  subCommands: {
+    // Essentials
+    merge,
+    split,
+    compress,
+    organize,
+
+    // Page Operations
+    rotate,
+    'delete-pages': deletePages,
+    duplicate,
+    reverse,
+
+    // Content & Modification
+    watermark,
+    'page-numbers': pageNumbers,
+    sign,
+    sanitize,
+
+    // Security
+    encrypt,
+    decrypt,
+
+    // Conversion & OCR
+    'to-images': toImages,
+    'from-images': fromImages,
+    'to-text': toText,
+    ocr,
+  },
+});

package/src/commands/pdf/merge.ts

@@ -0,0 +1,84 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const merge = defineCommand({
+  meta: {
+    name: 'merge',
+    description: 'Merge multiple PDF files into one',
+  },
+  args: {
+    files: {
+      type: 'positional',
+      description: 'PDF files to merge (at least 2)',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const output = requireArg(args.output, 'output');
+      const files = args._ as string[];
+
+      if (!files || files.length < 2) {
+        throw new Error('At least 2 PDF files are required to merge');
+      }
+
+      // Validate all files exist
+      for (const file of files) {
+        const resolved = resolvePath(file);
+        if (!existsSync(resolved)) {
+          throw new FileNotFoundError(file);
+        }
+      }
+
+      const outputPath = resolvePath(output);
+      ensureDir(outputPath);
+
+      const { PDFDocument } = await import('pdf-lib');
+
+      await withSpinner(
+        `Merging ${files.length} PDF files...`,
+        async () => {
+          const mergedPdf = await PDFDocument.create();
+
+          for (const file of files) {
+            const filePath = resolvePath(file);
+            const pdfBytes = await Bun.file(filePath).arrayBuffer();
+            const pdf = await PDFDocument.load(pdfBytes);
+            const pages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+
+            for (const page of pages) {
+              mergedPdf.addPage(page);
+            }
+          }
+
+          const mergedBytes = await mergedPdf.save();
+          await Bun.write(outputPath, mergedBytes);
+        },
+        'PDFs merged successfully'
+      );
+
+      const totalInputSize = files.reduce((sum, file) => {
+        return sum + getFileSize(resolvePath(file));
+      }, 0);
+
+      fileResult(`${files.length} files`, outputPath, {
+        before: totalInputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success(`Merged ${files.length} PDFs into ${output}`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});