noupload 1.0.0

package/src/commands/pdf/sanitize.ts

@@ -0,0 +1,77 @@
+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, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const sanitize = defineCommand({
+  meta: {
+    name: 'sanitize',
+    description: 'Remove metadata and hidden data from a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF 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, '-sanitized');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        'Sanitizing PDF...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const pdf = await PDFDocument.load(pdfBytes);
+
+          // Remove all metadata
+          pdf.setTitle('');
+          pdf.setAuthor('');
+          pdf.setSubject('');
+          pdf.setKeywords([]);
+          pdf.setProducer('');
+          pdf.setCreator('');
+          pdf.setCreationDate(new Date(0));
+          pdf.setModificationDate(new Date(0));
+
+          // Save the sanitized PDF
+          const sanitizedBytes = await pdf.save({
+            useObjectStreams: true,
+            addDefaultPage: false,
+          });
+
+          await Bun.write(outputPath, sanitizedBytes);
+        },
+        'PDF sanitized successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Removed metadata and hidden data from PDF');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/sign.ts

@@ -0,0 +1,156 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+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';
+
+type SignPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left' | 'center';
+
+export const sign = defineCommand({
+  meta: {
+    name: 'sign',
+    description: 'Add a signature image to a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    image: {
+      type: 'string',
+      alias: 'i',
+      description: 'Signature image file (PNG, JPG)',
+      required: true,
+    },
+    page: {
+      type: 'string',
+      alias: 'p',
+      description: 'Page to add signature to (default: last page)',
+    },
+    position: {
+      type: 'string',
+      description: 'Position: bottom-right, bottom-left, top-right, top-left, center',
+      default: 'bottom-right',
+    },
+    width: {
+      type: 'string',
+      alias: 'w',
+      description: 'Signature width in pixels',
+      default: '150',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const imagePath = requireArg(args.image, 'image');
+
+      const inputPath = resolvePath(input as string);
+      const signaturePath = resolvePath(imagePath);
+
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+      if (!existsSync(signaturePath)) {
+        throw new FileNotFoundError(imagePath);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-signed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const position = (args.position || 'bottom-right') as SignPosition;
+      const signatureWidth = Number.parseInt(args.width || '150', 10);
+
+      await withSpinner(
+        'Adding signature...',
+        async () => {
+          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();
+
+          // Embed image
+          const signatureImage = await pdf.embedPng(processedSignature);
+          const signatureDims = signatureImage.scale(1);
+
+          // Determine which page to sign
+          const totalPages = pdf.getPageCount();
+          const pageNum = args.page ? Number.parseInt(args.page, 10) - 1 : totalPages - 1;
+          const page = pdf.getPages()[pageNum];
+
+          if (!page) {
+            throw new Error(`Page ${pageNum + 1} does not exist`);
+          }
+
+          const { width, height } = page.getSize();
+
+          // Calculate position
+          let x: number;
+          let y: number;
+          const margin = 50;
+
+          switch (position) {
+            case 'bottom-left':
+              x = margin;
+              y = margin;
+              break;
+            case 'bottom-right':
+              x = width - signatureDims.width - margin;
+              y = margin;
+              break;
+            case 'top-left':
+              x = margin;
+              y = height - signatureDims.height - margin;
+              break;
+            case 'top-right':
+              x = width - signatureDims.width - margin;
+              y = height - signatureDims.height - margin;
+              break;
+            case 'center':
+              x = (width - signatureDims.width) / 2;
+              y = (height - signatureDims.height) / 2;
+              break;
+            default:
+              x = width - signatureDims.width - margin;
+              y = margin;
+          }
+
+          // Draw signature
+          page.drawImage(signatureImage, {
+            x,
+            y,
+            width: signatureDims.width,
+            height: signatureDims.height,
+          });
+
+          const signedBytes = await pdf.save();
+          await Bun.write(outputPath, signedBytes);
+        },
+        'Signature added successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('PDF signed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/split.ts

@@ -0,0 +1,148 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureOutputDir, getBasename, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+// Parse page range string like "1-5,7,10-15" into array of page indices (0-based)
+function parsePageRanges(rangeStr: string, totalPages: number): number[] {
+  const pages: Set<number> = new Set();
+  const parts = rangeStr.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));
+      const startPage = Math.max(1, start);
+      const endPage = Math.min(totalPages, end);
+      for (let i = startPage; i <= endPage; i++) {
+        pages.add(i - 1); // Convert to 0-based index
+      }
+    } else {
+      const page = Number.parseInt(part, 10);
+      if (page >= 1 && page <= totalPages) {
+        pages.add(page - 1);
+      }
+    }
+  }
+
+  return Array.from(pages).sort((a, b) => a - b);
+}
+
+export const split = defineCommand({
+  meta: {
+    name: 'split',
+    description: 'Split a PDF into multiple files',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory',
+      required: true,
+    },
+    pages: {
+      type: 'string',
+      alias: 'p',
+      description: 'Page ranges to extract (e.g., "1-5,10-15")',
+    },
+    every: {
+      type: 'string',
+      alias: 'e',
+      description: 'Split every N pages',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const output = requireArg(args.output, 'output');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputDir = resolvePath(output);
+      ensureOutputDir(`${outputDir}/`);
+
+      const inputSize = getFileSize(inputPath);
+      const basename = getBasename(inputPath);
+
+      await withSpinner(
+        'Splitting PDF...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const pdf = await PDFDocument.load(pdfBytes);
+          const totalPages = pdf.getPageCount();
+
+          if (args.every) {
+            // Split every N pages
+            const chunkSize = Number.parseInt(args.every, 10);
+            let chunkIndex = 1;
+
+            for (let start = 0; start < totalPages; start += chunkSize) {
+              const end = Math.min(start + chunkSize, totalPages);
+              const newPdf = await PDFDocument.create();
+              const pages = await newPdf.copyPages(
+                pdf,
+                Array.from({ length: end - start }, (_, i) => start + i)
+              );
+
+              for (const page of pages) {
+                newPdf.addPage(page);
+              }
+
+              const outputPath = join(outputDir, `${basename}_part${chunkIndex}.pdf`);
+              const bytes = await newPdf.save();
+              await Bun.write(outputPath, bytes);
+              chunkIndex++;
+            }
+
+            info(`Created ${chunkIndex - 1} PDF files`);
+          } else if (args.pages) {
+            // Extract specific pages
+            const pageIndices = parsePageRanges(args.pages, totalPages);
+            const newPdf = await PDFDocument.create();
+            const pages = await newPdf.copyPages(pdf, pageIndices);
+
+            for (const page of pages) {
+              newPdf.addPage(page);
+            }
+
+            const outputPath = join(outputDir, `${basename}_pages.pdf`);
+            const bytes = await newPdf.save();
+            await Bun.write(outputPath, bytes);
+
+            info(`Extracted ${pageIndices.length} pages`);
+          } else {
+            // Split into individual pages
+            for (let i = 0; i < totalPages; i++) {
+              const newPdf = await PDFDocument.create();
+              const [page] = await newPdf.copyPages(pdf, [i]);
+              newPdf.addPage(page);
+
+              const outputPath = join(outputDir, `${basename}_page${i + 1}.pdf`);
+              const bytes = await newPdf.save();
+              await Bun.write(outputPath, bytes);
+            }
+
+            info(`Created ${totalPages} individual page files`);
+          }
+        },
+        'PDF split successfully'
+      );
+
+      fileResult(inputPath, outputDir, { before: inputSize, after: 0 });
+      success(`PDF split into ${outputDir}`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

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

@@ -0,0 +1,84 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureOutputDir, getBasename, resolvePath } from '../../utils/files';
+import { info, success } from '../../utils/logger';
+import { convertPdfToImages } from '../../utils/pdf-tools';
+import { withSpinner } from '../../utils/progress';
+
+export const toImages = defineCommand({
+  meta: {
+    name: 'to-images',
+    description: 'Convert PDF pages to images',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory',
+      required: true,
+    },
+    format: {
+      type: 'string',
+      alias: 'f',
+      description: 'Image format: png, jpg',
+      default: 'png',
+    },
+    dpi: {
+      type: 'string',
+      alias: 'd',
+      description: 'Resolution in DPI',
+      default: '150',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const output = requireArg(args.output, 'output');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputDir = resolvePath(output);
+      ensureOutputDir(`${outputDir}/`);
+
+      const format = (args.format || 'png').toLowerCase() as 'png' | 'jpg';
+      const dpi = Number.parseInt(args.dpi || '150', 10);
+      const basename = getBasename(inputPath);
+
+      // Get page count
+      const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+      const pdf = await PDFDocument.load(pdfBytes);
+      const pageCount = pdf.getPageCount();
+
+      info(`PDF has ${pageCount} pages. Converting...`);
+
+      const files = await withSpinner(
+        'Converting pages to images...',
+        async () => {
+          return await convertPdfToImages({
+            pdfPath: inputPath,
+            outputDir,
+            dpi,
+            format,
+            basename,
+          });
+        },
+        `Converted ${pageCount} pages`
+      );
+
+      success(`Images saved to: ${outputDir}`);
+      info(`Created ${files.length} files`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/to-text.ts

@@ -0,0 +1,51 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, resolvePath } from '../../utils/files';
+import { success } from '../../utils/logger';
+import { extractPdfText } from '../../utils/pdf-tools';
+import { withSpinner } from '../../utils/progress';
+
+export const toText = defineCommand({
+  meta: {
+    name: 'to-text',
+    description: 'Extract text content from a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output text file',
+    },
+  },
+  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, '', 'txt');
+      ensureDir(outputPath);
+
+      await withSpinner(
+        'Extracting text...',
+        async () => {
+          await extractPdfText(inputPath, outputPath);
+        },
+        'Text extraction complete'
+      );
+
+      success(`Text saved to: ${outputPath}`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/watermark.ts

@@ -0,0 +1,179 @@
+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' | 'diagonal';
+
+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.5, g: 0.5, b: 0.5 };
+  }
+  return {
+    r: Number.parseInt(result[1], 16) / 255,
+    g: Number.parseInt(result[2], 16) / 255,
+    b: Number.parseInt(result[3], 16) / 255,
+  };
+}
+
+export const watermark = defineCommand({
+  meta: {
+    name: 'watermark',
+    description: 'Add a text watermark to a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    text: {
+      type: 'string',
+      alias: 't',
+      description: 'Watermark text',
+      required: true,
+    },
+    opacity: {
+      type: 'string',
+      description: 'Opacity (0.0 - 1.0)',
+      default: '0.3',
+    },
+    size: {
+      type: 'string',
+      alias: 's',
+      description: 'Font size',
+      default: '50',
+    },
+    color: {
+      type: 'string',
+      alias: 'c',
+      description: 'Text color (hex)',
+      default: '#888888',
+    },
+    position: {
+      type: 'string',
+      alias: 'p',
+      description: 'Position: center, diagonal, top-left, top-right, bottom-left, bottom-right',
+      default: 'diagonal',
+    },
+    x: {
+      type: 'string',
+      description: 'Custom X coordinate (overrides position)',
+    },
+    y: {
+      type: 'string',
+      description: 'Custom Y coordinate (overrides position)',
+    },
+  },
+  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 opacity = Number.parseFloat(args.opacity || '0.3');
+      const fontSize = Number.parseInt(args.size || '50', 10);
+      const color = hexToRgb(args.color || '#888888');
+      const position = (args.position || 'diagonal') as Position;
+      const customX = args.x ? Number.parseInt(args.x, 10) : undefined;
+      const customY = args.y ? Number.parseInt(args.y, 10) : undefined;
+
+      const { PDFDocument, StandardFonts, rgb } = await import('pdf-lib');
+
+      await withSpinner(
+        'Adding watermark...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const pdf = await PDFDocument.load(pdfBytes);
+          const font = await pdf.embedFont(StandardFonts.Helvetica);
+          const pages = pdf.getPages();
+
+          for (const page of pages) {
+            const { width, height } = page.getSize();
+            const textWidth = font.widthOfTextAtSize(text, fontSize);
+
+            let x: number;
+            let y: number;
+            let rotate = 0;
+
+            if (customX !== undefined && customY !== undefined) {
+              x = customX;
+              y = customY;
+            } else {
+              switch (position) {
+                case 'center':
+                  x = (width - textWidth) / 2;
+                  y = height / 2;
+                  break;
+                case 'diagonal':
+                  x = width / 4;
+                  y = height / 3;
+                  rotate = 45;
+                  break;
+                case 'top-left':
+                  x = 50;
+                  y = height - 50 - fontSize;
+                  break;
+                case 'top-right':
+                  x = width - textWidth - 50;
+                  y = height - 50 - fontSize;
+                  break;
+                case 'bottom-left':
+                  x = 50;
+                  y = 50;
+                  break;
+                case 'bottom-right':
+                  x = width - textWidth - 50;
+                  y = 50;
+                  break;
+                default:
+                  x = (width - textWidth) / 2;
+                  y = height / 2;
+              }
+            }
+
+            page.drawText(text, {
+              x,
+              y,
+              size: fontSize,
+              font,
+              color: rgb(color.r, color.g, color.b),
+              opacity,
+              // biome-ignore lint/suspicious/noExplicitAny: internal rotation object structure
+              rotate: rotate ? ({ type: 'degrees', angle: rotate } as any) : undefined,
+            });
+          }
+
+          const watermarkedBytes = await pdf.save();
+          await Bun.write(outputPath, watermarkedBytes);
+        },
+        'Watermark added successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success(`Added watermark "${text}" to all pages`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});