noupload 1.0.0

package/src/commands/qr/bulk-generate.ts

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import QRCode from 'qrcode';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, resolvePath } from '../../utils/files';
+import { info, success, warn } from '../../utils/logger';
+import { withProgressBar } from '../../utils/progress';
+
+export const bulkGenerate = defineCommand({
+  meta: {
+    name: 'bulk-generate',
+    description: 'Generate multiple QR codes from a text file (one per line)',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input text file with content (one item per line)',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory (default: ./qr-codes)',
+      default: './qr-codes',
+    },
+    format: {
+      type: 'string',
+      alias: 'f',
+      description: 'Output format: png, svg (default: png)',
+      default: 'png',
+    },
+    size: {
+      type: 'string',
+      alias: 's',
+      description: 'Size/scale of the QR codes (default: 10)',
+      default: '10',
+    },
+    prefix: {
+      type: 'string',
+      alias: 'p',
+      description: 'Filename prefix (default: qr)',
+      default: 'qr',
+    },
+    errorLevel: {
+      type: 'string',
+      alias: 'e',
+      description: 'Error correction level: L, M, Q, H (default: M)',
+      default: 'M',
+    },
+  },
+  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);
+      }
+
+      // Read lines from input file
+      const content = readFileSync(inputPath, 'utf-8');
+      const lines = content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('#'));
+
+      if (lines.length === 0) {
+        warn('No content found in input file');
+        return;
+      }
+
+      const outputDir = resolvePath(args.output || './qr-codes');
+      ensureDir(join(outputDir, 'dummy.txt')); // Ensure directory exists
+
+      const format = (args.format || 'png').toLowerCase();
+      const scale = Number.parseInt(args.size || '10', 10);
+      const prefix = args.prefix || 'qr';
+      const errorLevel = (args.errorLevel || 'M').toUpperCase() as 'L' | 'M' | 'Q' | 'H';
+
+      if (!['L', 'M', 'Q', 'H'].includes(errorLevel)) {
+        throw new Error('Error level must be L, M, Q, or H');
+      }
+
+      const options: QRCode.QRCodeToFileOptions = {
+        scale,
+        margin: 4,
+        errorCorrectionLevel: errorLevel,
+      };
+
+      info(`Generating ${lines.length} QR codes...`);
+
+      let generated = 0;
+      let failed = 0;
+
+      await withProgressBar(
+        lines,
+        async (line: string, index: number) => {
+          const filename = `${prefix}-${String(index + 1).padStart(4, '0')}.${format}`;
+          const outputFilePath = join(outputDir, filename);
+
+          try {
+            if (format === 'svg') {
+              const svg = await QRCode.toString(line, {
+                type: 'svg',
+                margin: 4,
+                errorCorrectionLevel: errorLevel,
+                width: scale * 25,
+              });
+              writeFileSync(outputFilePath, svg);
+            } else {
+              await QRCode.toFile(outputFilePath, line, options);
+            }
+            generated++;
+          } catch {
+            failed++;
+          }
+        },
+        {
+          label: 'Generating QR codes',
+        }
+      );
+
+      info(`Output directory: ${outputDir}`);
+      info(`Format: ${format.toUpperCase()}, Scale: ${scale}x, Error Level: ${errorLevel}`);
+
+      if (failed > 0) {
+        warn(`${failed} QR codes failed to generate`);
+      }
+
+      success(`${generated} QR codes generated`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/qr/generate.ts

@@ -0,0 +1,128 @@
+import { basename, dirname, join } from 'node:path';
+import { defineCommand } from 'citty';
+import QRCode from 'qrcode';
+import { handleError, requireArg } from '../../utils/errors';
+import { ensureDir, getFileSize, resolvePath } from '../../utils/files';
+import { info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const generate = defineCommand({
+  meta: {
+    name: 'generate',
+    description: 'Generate a QR code from text or URL',
+  },
+  args: {
+    content: {
+      type: 'positional',
+      description: 'Text or URL to encode in QR code',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path (default: qr.png)',
+    },
+    format: {
+      type: 'string',
+      alias: 'f',
+      description: 'Output format: png, svg, terminal (default: png)',
+      default: 'png',
+    },
+    size: {
+      type: 'string',
+      alias: 's',
+      description: 'Size/scale of the QR code (default: 10)',
+      default: '10',
+    },
+    margin: {
+      type: 'string',
+      alias: 'm',
+      description: 'Margin around QR code in modules (default: 4)',
+      default: '4',
+    },
+    errorLevel: {
+      type: 'string',
+      alias: 'e',
+      description: 'Error correction level: L, M, Q, H (default: M)',
+      default: 'M',
+    },
+    dark: {
+      type: 'string',
+      description: 'Dark module color (default: #000000)',
+      default: '#000000',
+    },
+    light: {
+      type: 'string',
+      description: 'Light module color (default: #ffffff)',
+      default: '#ffffff',
+    },
+  },
+  async run({ args }) {
+    try {
+      const content = requireArg(args.content, 'content') as string;
+      const format = (args.format || 'png').toLowerCase();
+      const scale = Number.parseInt(args.size || '10', 10);
+      const margin = Number.parseInt(args.margin || '4', 10);
+      const errorLevel = (args.errorLevel || 'M').toUpperCase() as 'L' | 'M' | 'Q' | 'H';
+
+      // Validate error correction level
+      if (!['L', 'M', 'Q', 'H'].includes(errorLevel)) {
+        throw new Error('Error level must be L, M, Q, or H');
+      }
+
+      const options: QRCode.QRCodeToFileOptions & QRCode.QRCodeToStringOptions = {
+        scale,
+        margin,
+        errorCorrectionLevel: errorLevel,
+        color: {
+          dark: args.dark || '#000000',
+          light: args.light || '#ffffff',
+        },
+      };
+
+      if (format === 'terminal') {
+        // Output to terminal
+        await withSpinner(
+          'Generating QR code...',
+          async () => {
+            const qrString = await QRCode.toString(content, { type: 'terminal', ...options });
+            console.log(`\n${qrString}`);
+          },
+          'QR code generated'
+        );
+      } else if (format === 'svg' || format === 'png') {
+        // Output to file
+        let outputPath: string;
+        if (args.output) {
+          outputPath = resolvePath(args.output);
+        } else {
+          outputPath = resolvePath(`qr.${format}`);
+        }
+        ensureDir(outputPath);
+
+        await withSpinner(
+          'Generating QR code...',
+          async () => {
+            if (format === 'svg') {
+              const svg = await QRCode.toString(content, { type: 'svg', ...options });
+              await Bun.write(outputPath, svg);
+            } else {
+              await QRCode.toFile(outputPath, content, options);
+            }
+          },
+          'QR code generated'
+        );
+
+        info(`Content: "${content.length > 50 ? `${content.slice(0, 47)}...` : content}"`);
+        info(`File: ${outputPath} (${getFileSize(outputPath)})`);
+        info(`Error correction: ${errorLevel}, Scale: ${scale}x`);
+      } else {
+        throw new Error(`Unknown format: ${format}. Use 'png', 'svg', or 'terminal'`);
+      }
+
+      success('QR code created');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/qr/index.ts

@@ -0,0 +1,16 @@
+import { defineCommand } from 'citty';
+import { bulkGenerate } from './bulk-generate';
+import { generate } from './generate';
+import { scan } from './scan';
+
+export const qr = defineCommand({
+  meta: {
+    name: 'qr',
+    description: 'QR code generation and scanning tools',
+  },
+  subCommands: {
+    generate,
+    scan,
+    'bulk-generate': bulkGenerate,
+  },
+});

package/src/commands/qr/scan.ts

@@ -0,0 +1,114 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import jsQR from 'jsqr';
+import sharp from 'sharp';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { resolvePath } from '../../utils/files';
+import { info, success, warn } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+interface ScanResult {
+  data: string;
+  location: {
+    topRightCorner: { x: number; y: number };
+    topLeftCorner: { x: number; y: number };
+    bottomRightCorner: { x: number; y: number };
+    bottomLeftCorner: { x: number; y: number };
+  };
+}
+
+export const scan = defineCommand({
+  meta: {
+    name: 'scan',
+    description: 'Scan and decode a QR code from an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file containing QR code',
+      required: true,
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output result as JSON',
+      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);
+      }
+
+      const result = await withSpinner(
+        'Scanning QR code...',
+        async (): Promise<ScanResult | null> => {
+          // Load image and convert to raw RGBA data
+          const image = sharp(inputPath);
+          const { width, height } = await image.metadata();
+
+          if (!width || !height) {
+            throw new Error('Could not read image dimensions');
+          }
+
+          // Convert to raw RGBA
+          const rawData = await image.ensureAlpha().raw().toBuffer();
+
+          // Create Uint8ClampedArray for jsQR
+          const data = new Uint8ClampedArray(rawData);
+
+          // Scan for QR code
+          const qrCode = jsQR(data, width, height);
+
+          if (qrCode) {
+            return {
+              data: qrCode.data,
+              location: qrCode.location,
+            };
+          }
+          return null;
+        },
+        'Scan complete'
+      );
+
+      if (result) {
+        if (args.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          info(`Content: ${result.data}`);
+
+          // Detect content type
+          const contentData = result.data;
+          if (contentData.startsWith('http://') || contentData.startsWith('https://')) {
+            info('Type: URL');
+          } else if (contentData.startsWith('mailto:')) {
+            info('Type: Email');
+          } else if (contentData.startsWith('tel:')) {
+            info('Type: Phone');
+          } else if (contentData.startsWith('WIFI:')) {
+            info('Type: WiFi Network');
+          } else if (contentData.startsWith('BEGIN:VCARD')) {
+            info('Type: Contact (vCard)');
+          } else if (contentData.startsWith('BEGIN:VEVENT')) {
+            info('Type: Calendar Event');
+          } else {
+            info('Type: Text');
+          }
+        }
+        success('QR code decoded');
+      } else {
+        warn('No QR code found in the image');
+        info('Tips:');
+        info('  - Ensure the QR code is clearly visible');
+        info('  - Try cropping the image to focus on the QR code');
+        info('  - Ensure good contrast and lighting');
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/setup.ts

@@ -0,0 +1,156 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { defineCommand } from 'citty';
+import { type ToolInfo, detectTool, getPackageMap } from '../utils/detect';
+import { error, info, success, warn } from '../utils/logger';
+import { c, sym } from '../utils/style';
+
+const TOOLS = [
+  { name: 'ffmpeg', check: 'ffmpeg' },
+  { name: 'ghostscript', check: 'gs', altCheck: 'gswin64c' },
+  { name: 'qpdf', check: 'qpdf' },
+  { name: 'mupdf', check: 'mutool' },
+  { name: 'poppler', check: 'pdftotext' },
+  { name: 'imagemagick', check: 'magick', altCheck: 'convert' },
+];
+
+async function detectPackageManager(): Promise<
+  'brew' | 'apt' | 'dnf' | 'pacman' | 'apk' | 'winget' | null
+> {
+  if (process.platform === 'darwin') {
+    if ((await detectTool('brew')).available) return 'brew';
+  } else if (process.platform === 'win32') {
+    if ((await detectTool('winget')).available) return 'winget';
+  } else if (process.platform === 'linux') {
+    if ((await detectTool('apt-get')).available) return 'apt';
+    if ((await detectTool('dnf')).available) return 'dnf';
+    if ((await detectTool('pacman')).available) return 'pacman';
+    if ((await detectTool('apk')).available) return 'apk';
+  }
+  return null;
+}
+
+function askConfirmation(question: string): Promise<boolean> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
+export const setup = defineCommand({
+  meta: {
+    name: 'setup',
+    description: 'Automatically install missing system dependencies',
+  },
+  args: {
+    yes: {
+      type: 'boolean',
+      alias: 'y',
+      description: 'Skip confirmation',
+    },
+  },
+  async run({ args }) {
+    console.log('');
+    info('NoUpload CLI Setup');
+    console.log(c.dim('  Checking environment...'));
+
+    // 1. Detect Package Manager
+    const pm = await detectPackageManager();
+    if (!pm) {
+      error('Could not detect a supported package manager (brew, apt, winget).');
+      console.log(
+        `  ${c.dim('Hint:')} Please install dependencies manually using "noupload doctor".`
+      );
+      return;
+    }
+    console.log(`  ${c.dim('Package Manager:')} ${c.active(pm)}`);
+
+    // 2. Detect Missing Tools
+    const missing: string[] = [];
+    const pkgMap = getPackageMap();
+
+    for (const tool of TOOLS) {
+      let available = (await detectTool(tool.check)).available;
+      if (!available && tool.altCheck) {
+        available = (await detectTool(tool.altCheck)).available;
+      }
+
+      if (!available) {
+        missing.push(tool.name);
+      }
+    }
+
+    if (missing.length === 0) {
+      success('All dependencies are already installed!');
+      return;
+    }
+
+    // 3. Build Install Command
+    const packages = missing.map((tool) => pkgMap[tool][pm]);
+    let cmd = '';
+    const cmdArgs: string[] = [];
+
+    if (pm === 'brew') {
+      cmd = 'brew';
+      cmdArgs.push('install', ...packages);
+    } else if (pm === 'apt') {
+      cmd = 'sudo';
+      cmdArgs.push('apt-get', 'install', '-y', ...packages);
+    } else if (pm === 'dnf') {
+      cmd = 'sudo';
+      cmdArgs.push('dnf', 'install', '-y', ...packages);
+    } else if (pm === 'pacman') {
+      cmd = 'sudo';
+      cmdArgs.push('pacman', '-S', '--noconfirm', ...packages);
+    } else if (pm === 'apk') {
+      cmd = 'sudo';
+      cmdArgs.push('apk', 'add', ...packages);
+    } else if (pm === 'winget') {
+      cmd = 'winget';
+      cmdArgs.push('install', ...packages);
+    }
+
+    const fullCmd = `${cmd} ${cmdArgs.join(' ')}`;
+
+    console.log('');
+    console.warn(`${c.warn(sym.warn)} ${c.warn(`Missing tools: ${missing.join(', ')}`)}`);
+    console.log(`  ${c.dim('Command:')} ${c.white(fullCmd)}`);
+    console.log('');
+
+    // 4. Confirm and Execute
+    if (!args.yes) {
+      const q = `${c.active(sym.input)} Run this command now? [y/N] `;
+      const confirmed = await askConfirmation(q);
+      if (!confirmed) {
+        console.log(c.dim('  Setup cancelled.'));
+        return;
+      }
+    }
+
+    console.log('');
+    console.log(c.dim('  Running installer... (you may be asked for your password)'));
+    console.log('');
+
+    const child = spawn(cmd, cmdArgs, {
+      stdio: 'inherit', // Important: Inherit stdio so user can interact/see progress
+      shell: true,
+    });
+
+    child.on('close', (code) => {
+      console.log('');
+      if (code === 0) {
+        success('Setup complete! All dependencies installed.');
+      } else {
+        error(`Installer failed with code ${code}.`);
+        console.log(c.dim('  Please try running the command manually.'));
+      }
+    });
+  },
+});

package/src/index.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+import { renderUsage, runMain } from 'citty';
+import { main } from './cli';
+import { hex } from './utils/colors';
+
+// Theme Colors
+const ORANGE = hex('#f59e0b');
+const PURPLE = hex('#a855f7'); // Tailwind Purple 500
+
+// biome-ignore lint/suspicious/noExplicitAny: generic wrapper for citty types
+async function customShowUsage(cmd: any, parent?: any) {
+  try {
+    let output = await renderUsage(cmd, parent);
+
+    // Fix ugly subcommand lists in USAGE line
+    // Replaces long lists like "merge|split|compress|..." with "<command>"
+    output = output.replace(/ ([a-z0-9-]+\|[a-z0-9-|]+)/g, ' <command>');
+
+    // Colorize commands in the list to Theme Orange
+    output = output.replace(/^\s+`([a-z0-9-]+)`/gm, (match, commandName) => {
+      const indentation = match.substring(0, match.indexOf('`'));
+      return `${indentation}${ORANGE(commandName)}`;
+    });
+
+    // Colorize footer example command to Theme Purple
+    output = output.replace(/Use `([^`]+)`/g, (match, content) => {
+      return `Use ${PURPLE(content)}`;
+    });
+
+    // Colorize remaining backticked items (Usage line) to Theme Orange
+    output = output.replace(/`([^`]+)`/g, (match, content) => {
+      // Backticks are already stripped from 'content' capture group
+      return ORANGE(content);
+    });
+
+    console.log(`${output}\n`);
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+runMain(main, { showUsage: customShowUsage });

package/src/lib/audio/ffmpeg.ts

@@ -0,0 +1,93 @@
+import { spawn } from 'node:child_process';
+import { detectFFmpeg, getInstallCommand } from '../../utils/detect';
+import { warn } from '../../utils/logger';
+import { c } from '../../utils/style';
+
+export interface FFmpegOptions {
+  input: string;
+  output: string;
+  args?: string[];
+}
+
+// Run FFmpeg command
+export async function runFFmpeg(options: FFmpegOptions): Promise<void> {
+  const ffmpeg = await detectFFmpeg();
+
+  if (!ffmpeg.available || !ffmpeg.path) {
+    const installCmd = getInstallCommand('ffmpeg');
+    throw new Error(`FFmpeg not found. ${installCmd ? `Install with: ${installCmd}` : ''}`);
+  }
+
+  const ffmpegPath = ffmpeg.path;
+
+  const args = [
+    '-y', // Overwrite output
+    '-i',
+    options.input,
+    ...(options.args || []),
+    options.output,
+  ];
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(ffmpegPath, args, {
+      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(`FFmpeg failed: ${stderr.slice(-500)}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+// Check if FFmpeg is available
+export async function checkFFmpeg(): Promise<boolean> {
+  const ffmpeg = await detectFFmpeg();
+
+  if (!ffmpeg.available) {
+    warn('FFmpeg is required for audio operations');
+    const installCmd = getInstallCommand('ffmpeg');
+    if (installCmd) {
+      console.log(`  ${c.active('Install:')} ${installCmd}`);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+// Parse time string to seconds (supports "HH:MM:SS" or "MM:SS" or seconds)
+export function parseTime(time: string): number {
+  if (time.includes(':')) {
+    const parts = time.split(':').map(Number);
+    if (parts.length === 3) {
+      return parts[0] * 3600 + parts[1] * 60 + parts[2];
+    }
+    if (parts.length === 2) {
+      return parts[0] * 60 + parts[1];
+    }
+  }
+  return Number.parseFloat(time);
+}
+
+// Format seconds to time string
+export function formatTime(seconds: number): string {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+
+  if (h > 0) {
+    return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+  }
+  return `${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+}