mpx-video 1.0.0

package/LICENSE

@@ -0,0 +1,14 @@
+mpx-video — Dual License
+
+Copyright (c) 2026 Mesaplex
+
+FREE TIER:
+Permission is granted to use this software free of charge for personal
+and evaluation purposes, subject to the daily usage limits built into
+the software.
+
+PRO TIER:
+A paid license removes all usage limits and unlocks additional features.
+Purchase at https://mesaplex.com/mpx-video
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

package/README.md

@@ -0,0 +1,120 @@
+# mpx-video
+
+**ffmpeg for humans** — Simple, beautiful video processing from the command line.
+
+Stop memorizing ffmpeg flags. `mpx-video` wraps ffmpeg with human-friendly commands, smart defaults, and beautiful output.
+
+## Install
+
+```bash
+npm install -g mpx-video
+```
+
+Requires [ffmpeg](https://ffmpeg.org/download.html) installed on your system.
+
+## Quick Start
+
+```bash
+# Get video info
+mpx-video info video.mp4
+
+# Compress a video (smart defaults, ~50% size reduction)
+mpx-video compress video.mp4
+
+# Convert format
+mpx-video convert video.mp4 webm
+
+# Trim a clip
+mpx-video trim video.mp4 --start 1:30 --end 2:00
+```
+
+## Commands
+
+### Free Tier (5/day)
+
+| Command | Description |
+|---------|-------------|
+| `info <file>` | Show duration, resolution, codec, bitrate, file size |
+| `compress <file> [output]` | Smart compression with configurable quality |
+| `convert <file> <format>` | Convert between mp4, webm, mov, avi, mkv, gif |
+| `trim <file>` | Cut video segments with human-friendly times |
+
+### Pro Tier (unlimited)
+
+| Command | Description |
+|---------|-------------|
+| `extract-audio <file>` | Extract audio as mp3, wav, aac, or flac |
+| `resize <file>` | Scale video to target width/height |
+| `gif <file>` | Create GIF from video segment |
+| `thumbnail <file>` | Generate thumbnail grid (4x4 default) |
+| `speed <file>` | Speed up or slow down playback |
+| `merge <files...>` | Concatenate multiple videos |
+| `watermark <file>` | Add text watermark |
+| `batch <dir>` | Batch process entire directories |
+
+## Examples
+
+```bash
+# Compress with high quality
+mpx-video compress video.mp4 -q high
+
+# Convert to GIF
+mpx-video convert video.mp4 gif
+
+# Trim with duration
+mpx-video trim video.mp4 --start 0:30 --duration 60s
+
+# Extract audio as WAV
+mpx-video extract-audio video.mp4 -f wav
+
+# Create 3-second GIF starting at 5s
+mpx-video gif video.mp4 --start 5 --duration 3
+
+# 2x speed
+mpx-video speed video.mp4 --factor 2
+
+# Resize to 720p
+mpx-video resize video.mp4 --width 1280
+
+# Add watermark
+mpx-video watermark video.mp4 --text "© 2026" --position top-right
+
+# Batch compress a folder
+mpx-video batch ./videos --action compress
+
+# JSON output for CI/CD
+mpx-video info video.mp4 --json
+```
+
+## Time Formats
+
+All time arguments accept human-friendly formats:
+
+- `90` or `90s` — 90 seconds
+- `1:30` — 1 minute 30 seconds
+- `01:30:00` — 1 hour 30 minutes
+
+## Licensing
+
+**Free tier:** 5 operations per day. Basic commands (info, compress, convert, trim).
+
+**Pro tier:** Unlimited operations. All commands including batch, extract-audio, gif, resize, speed, merge, watermark, thumbnail.
+
+```bash
+# Check license status
+mpx-video license
+
+# Activate Pro
+mpx-video activate MPX-PRO-XXXXXXXX
+```
+
+Get Pro at [mesaplex.com/mpx-video](https://mesaplex.com/mpx-video)
+
+## Requirements
+
+- Node.js >= 16
+- ffmpeg and ffprobe installed
+
+## License
+
+Dual license — Free tier for personal use, Pro license for commercial and unlimited use.

package/bin/cli.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { requireFfmpeg } = require('../src/utils/ffmpeg');
+const { getLicense, activateLicense, checkRateLimit, recordUsage, FREE_DAILY_LIMIT } = require('../src/license');
+
+const program = new Command();
+program.name('mpx-video').description('ffmpeg for humans — simple video processing CLI').version('1.0.0');
+
+function requireFile(filePath) {
+  const fs = require('fs');
+  if (!fs.existsSync(filePath)) { console.error(chalk.red(`  ✗ File not found: ${filePath}`)); process.exit(1); }
+}
+
+function gate(pro = false) {
+  requireFfmpeg();
+  const license = getLicense();
+  if (pro && license.tier !== 'pro') {
+    console.error(chalk.yellow('\n  ⚡ Pro feature — upgrade at https://mesaplex.com/mpx-video\n'));
+    console.error(chalk.dim('  Activate with: mpx-video activate <license-key>\n'));
+    process.exit(1);
+  }
+  const limit = checkRateLimit();
+  if (!limit.allowed) {
+    console.error(chalk.yellow(`\n  Daily limit reached (${FREE_DAILY_LIMIT}/day). Resets tomorrow.`));
+    console.error(chalk.dim('  Upgrade to Pro for unlimited: https://mesaplex.com/mpx-video\n'));
+    process.exit(1);
+  }
+  if (limit.remaining > 0) console.log(chalk.dim(`  Free tier: ${limit.remaining} operation(s) remaining today`));
+  recordUsage();
+}
+
+// Free tier commands
+program.command('info <file>').description('Show video file information').option('--json', 'JSON output').action(async (file, opts) => {
+  requireFfmpeg(); requireFile(file);
+  await require('../src/commands/info')(file, opts);
+});
+
+program.command('compress <file> [output]').description('Smart video compression').option('-q, --quality <level>', 'Quality: high, medium, low', 'medium').option('--fast', 'Fast encoding (larger file)').action(async (file, output, opts) => {
+  requireFile(file); gate();
+  await require('../src/commands/compress')(file, output, opts);
+});
+
+program.command('convert <file> <format>').description('Convert video format (mp4, webm, mov, avi, mkv, gif)').option('-o, --output <path>', 'Output path').action(async (file, format, opts) => {
+  requireFile(file); gate();
+  await require('../src/commands/convert')(file, format, opts);
+});
+
+program.command('trim <file>').description('Trim video segment').option('-s, --start <time>', 'Start time (0:30, 90s, 1:30:00)').option('-e, --end <time>', 'End time').option('-d, --duration <time>', 'Duration from start').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate();
+  await require('../src/commands/trim')(file, opts);
+});
+
+// Pro commands
+program.command('extract-audio <file>').description('Extract audio track [Pro]').option('-f, --format <fmt>', 'Audio format: mp3, wav, aac, flac', 'mp3').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate(true);
+  await require('../src/commands/extract-audio')(file, opts);
+});
+
+program.command('resize <file>').description('Resize/scale video [Pro]').option('-w, --width <px>', 'Target width').option('-h, --height <px>', 'Target height', '-1').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate(true);
+  await require('../src/commands/resize')(file, opts);
+});
+
+program.command('gif <file>').description('Create GIF from video [Pro]').option('-s, --start <time>', 'Start time', '0').option('-d, --duration <time>', 'Duration in seconds', '5').option('-w, --width <px>', 'GIF width', '480').option('--fps <n>', 'Frames per second', '15').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate(true);
+  await require('../src/commands/gif')(file, opts);
+});
+
+program.command('thumbnail <file>').description('Generate thumbnail grid [Pro]').option('--cols <n>', 'Grid columns', '4').option('--rows <n>', 'Grid rows', '4').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate(true);
+  await require('../src/commands/thumbnail')(file, opts);
+});
+
+program.command('speed <file>').description('Change playback speed [Pro]').option('-f, --factor <n>', 'Speed factor (2 = 2x faster, 0.5 = half speed)', '2').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate(true);
+  await require('../src/commands/speed')(file, opts);
+});
+
+program.command('merge <files...>').description('Concatenate videos [Pro]').option('-o, --output <path>', 'Output path', 'merged-output.mp4').action(async (files, opts) => {
+  files.forEach(requireFile); gate(true);
+  await require('../src/commands/merge')(files, opts);
+});
+
+program.command('watermark <file>').description('Add text watermark [Pro]').option('-t, --text <text>', 'Watermark text').option('-p, --position <pos>', 'Position: top-left, top-right, bottom-left, bottom-right, center', 'bottom-right').option('--font-size <px>', 'Font size', '24').option('-o, --output <path>', 'Output path').action(async (file, opts) => {
+  requireFile(file); gate(true);
+  await require('../src/commands/watermark')(file, opts);
+});
+
+program.command('batch <dir>').description('Batch process directory [Pro]').option('-a, --action <action>', 'Action: compress, convert, resize').option('-q, --quality <level>', 'Quality for compress').option('-w, --width <px>', 'Width for resize').option('-o, --output <path>', 'Output directory').action(async (dir, opts) => {
+  gate(true);
+  await require('../src/commands/batch')(dir, opts);
+});
+
+// License management
+program.command('activate <key>').description('Activate Pro license').action((key) => {
+  try {
+    activateLicense(key);
+    console.log(chalk.bold.green('\n  ✓ Pro license activated!\n'));
+  } catch (err) { console.error(chalk.red(`\n  ✗ ${err.message}\n`)); process.exit(1); }
+});
+
+program.command('license').description('Check license status').action(() => {
+  const l = getLicense();
+  const rl = checkRateLimit();
+  console.log('');
+  console.log(chalk.bold('  License Status'));
+  console.log('  ──────────────────────────────────────');
+  console.log('  Tier:    ' + (l.tier === 'pro' ? chalk.green('Pro') : 'Free'));
+  if (l.tier === 'free') {
+    console.log('  Limit:   ' + FREE_DAILY_LIMIT + ' ops/day');
+    console.log('  Today:   ' + (FREE_DAILY_LIMIT - (rl.remaining >= 0 ? rl.remaining : 0)) + '/' + FREE_DAILY_LIMIT + ' used');
+  } else {
+    console.log('  Limit:   Unlimited');
+  }
+  console.log('  ──────────────────────────────────────');
+  if (l.tier === 'free') {
+    console.log('');
+    console.log('  Upgrade: https://mesaplex.com/mpx-video');
+    console.log('  Activate: mpx-video activate <license-key>');
+  }
+  console.log('');
+});
+
+program.parse();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "mpx-video",
+  "version": "1.0.0",
+  "description": "ffmpeg for humans — simple video processing CLI",
+  "main": "src/index.js",
+  "bin": {
+    "mpx-video": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "node test/run.js"
+  },
+  "keywords": ["ffmpeg", "video", "cli", "compress", "convert", "trim", "developer-tools"],
+  "author": "Mesaplex <support@mesaplex.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mesaplexdev/mpx-video"
+  },
+  "homepage": "https://github.com/mesaplexdev/mpx-video#readme",
+  "bugs": "https://github.com/mesaplexdev/mpx-video/issues",
+  "dependencies": {
+    "chalk": "4.1.2",
+    "commander": "^12.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/commands/batch.js

@@ -0,0 +1,36 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+
+const VIDEO_EXTS = ['.mp4', '.mov', '.avi', '.mkv', '.webm', '.flv', '.wmv', '.m4v'];
+
+async function batch(dir, opts) {
+  const action = opts.action;
+  if (!action) { console.error(chalk.red('  ✗ Specify --action (compress|convert|resize)')); process.exit(1); }
+
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    console.error(chalk.red('  ✗ Not a directory: ') + dir); process.exit(1);
+  }
+
+  const files = fs.readdirSync(dir).filter(f => VIDEO_EXTS.includes(path.extname(f).toLowerCase())).map(f => path.join(dir, f));
+
+  if (files.length === 0) { console.log(chalk.yellow('  No video files found in ' + dir)); return; }
+
+  console.log('');
+  console.log(chalk.bold.cyan(`  📦 Batch ${action}: `) + files.length + ' files');
+
+  const handler = require(`./${action}`);
+  for (let i = 0; i < files.length; i++) {
+    console.log(chalk.dim(`  [${i + 1}/${files.length}]`));
+    try {
+      await handler(files[i], opts);
+    } catch (err) {
+      console.error(chalk.red(`  ✗ Failed: ${files[i]}: ${err.message}`));
+    }
+  }
+
+  console.log(chalk.bold.green(`  ✓ Batch complete: ${files.length} files processed`));
+  console.log('');
+}
+
+module.exports = batch;

package/src/commands/compress.js

@@ -0,0 +1,44 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { probe, run, formatBytes } = require('../utils/ffmpeg');
+
+async function compress(filePath, output, opts) {
+  const ext = path.extname(filePath);
+  if (!output) output = filePath.replace(ext, `-compressed${ext}`);
+
+  const data = probe(filePath);
+  const origSize = parseInt(data.format.size || 0);
+  const duration = parseFloat(data.format.duration || 0);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🎬 Compressing: ') + path.basename(filePath));
+  console.log(chalk.dim('     Original: ') + formatBytes(origSize));
+
+  const crf = opts.quality === 'high' ? '23' : opts.quality === 'low' ? '32' : '28';
+  const preset = opts.fast ? 'fast' : 'medium';
+
+  const args = ['-i', filePath, '-c:v', 'libx264', '-crf', crf, '-preset', preset, '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', '-y', output];
+
+  const start = Date.now();
+  await run(args, {
+    onProgress: (secs) => {
+      if (duration > 0) {
+        const pct = Math.min(100, Math.round((secs / duration) * 100));
+        process.stdout.write(`\r     Progress:  ${chalk.yellow(pct + '%')} ${'█'.repeat(Math.round(pct / 3))}${'░'.repeat(33 - Math.round(pct / 3))}`);
+      }
+    }
+  });
+
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+  const newSize = fs.statSync(output).size;
+  const reduction = origSize > 0 ? Math.round((1 - newSize / origSize) * 100) : 0;
+
+  console.log('');
+  console.log(chalk.bold.green('  ✓ Done') + chalk.dim(` in ${elapsed}s`));
+  console.log(chalk.dim('     Output:   ') + output);
+  console.log(chalk.dim('     Size:     ') + formatBytes(newSize) + chalk.dim(` (${reduction}% smaller)`));
+  console.log('');
+}
+
+module.exports = compress;

package/src/commands/convert.js

@@ -0,0 +1,39 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, formatBytes } = require('../utils/ffmpeg');
+
+const CODEC_MAP = {
+  mp4: ['-c:v', 'libx264', '-c:a', 'aac'],
+  webm: ['-c:v', 'libvpx-vp9', '-c:a', 'libopus'],
+  mov: ['-c:v', 'libx264', '-c:a', 'aac'],
+  avi: ['-c:v', 'libx264', '-c:a', 'mp3'],
+  mkv: ['-c:v', 'libx264', '-c:a', 'aac'],
+  gif: ['-vf', 'fps=15,scale=480:-1:flags=lanczos', '-an'],
+};
+
+async function convert(filePath, format, opts) {
+  format = format.replace(/^\./, '').toLowerCase();
+  if (!CODEC_MAP[format]) {
+    console.error(chalk.red(`  ✗ Unsupported format: ${format}`));
+    console.error(chalk.dim(`    Supported: ${Object.keys(CODEC_MAP).join(', ')}`));
+    process.exit(1);
+  }
+
+  const output = opts.output || filePath.replace(path.extname(filePath), `.${format}`);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🔄 Converting: ') + path.basename(filePath) + chalk.dim(` → .${format}`));
+
+  const args = ['-i', filePath, ...CODEC_MAP[format], '-y', output];
+  const start = Date.now();
+  await run(args);
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done') + chalk.dim(` in ${elapsed}s`));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = convert;

package/src/commands/extract-audio.js

@@ -0,0 +1,24 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, formatBytes } = require('../utils/ffmpeg');
+
+async function extractAudio(filePath, opts) {
+  const format = opts.format || 'mp3';
+  const output = opts.output || filePath.replace(path.extname(filePath), `.${format}`);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🎵 Extracting audio: ') + path.basename(filePath));
+
+  const codecMap = { mp3: ['-c:a', 'libmp3lame', '-q:a', '2'], wav: ['-c:a', 'pcm_s16le'], aac: ['-c:a', 'aac', '-b:a', '192k'], flac: ['-c:a', 'flac'] };
+  const codec = codecMap[format] || codecMap.mp3;
+
+  await run(['-i', filePath, '-vn', ...codec, '-y', output]);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = extractAudio;

package/src/commands/gif.js

@@ -0,0 +1,25 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, parseTime, formatBytes } = require('../utils/ffmpeg');
+
+async function gif(filePath, opts) {
+  const output = opts.output || filePath.replace(path.extname(filePath), '.gif');
+  const start = opts.start ? parseTime(opts.start) : 0;
+  const duration = opts.duration ? parseTime(opts.duration) : 5;
+  const width = opts.width || 480;
+  const fps = opts.fps || 15;
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🎞️  Creating GIF: ') + path.basename(filePath));
+
+  const args = ['-i', filePath, '-ss', String(start), '-t', String(duration), '-vf', `fps=${fps},scale=${width}:-1:flags=lanczos`, '-an', '-y', output];
+  await run(args);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = gif;

package/src/commands/info.js

@@ -0,0 +1,52 @@
+const chalk = require('chalk');
+const { probe, formatTime, formatBytes } = require('../utils/ffmpeg');
+
+async function info(filePath, opts) {
+  const data = probe(filePath);
+  const fmt = data.format || {};
+  const video = data.streams.find(s => s.codec_type === 'video');
+  const audio = data.streams.find(s => s.codec_type === 'audio');
+
+  if (opts.json) {
+    console.log(JSON.stringify({ file: filePath, format: fmt.format_long_name, duration: parseFloat(fmt.duration), size: parseInt(fmt.size), video: video ? { codec: video.codec_name, width: video.width, height: video.height, fps: eval(video.r_frame_rate), bitrate: parseInt(video.bit_rate) } : null, audio: audio ? { codec: audio.codec_name, sampleRate: parseInt(audio.sample_rate), channels: audio.channels, bitrate: parseInt(audio.bit_rate) } : null }, null, 2));
+    return;
+  }
+
+  const duration = parseFloat(fmt.duration || 0);
+  const size = parseInt(fmt.size || 0);
+
+  console.log('');
+  console.log(chalk.bold.cyan('┌─────────────────────────────────────────────────────────────┐'));
+  console.log(chalk.bold.cyan('│') + chalk.bold('         mpx-video — File Information                       ') + chalk.bold.cyan('│'));
+  console.log(chalk.bold.cyan('└─────────────────────────────────────────────────────────────┘'));
+  console.log('');
+  console.log(chalk.bold('  File:      ') + filePath);
+  console.log(chalk.bold('  Format:    ') + (fmt.format_long_name || fmt.format_name || 'unknown'));
+  console.log(chalk.bold('  Duration:  ') + formatTime(duration));
+  console.log(chalk.bold('  Size:      ') + formatBytes(size));
+  console.log(chalk.bold('  Bitrate:   ') + (fmt.bit_rate ? Math.round(fmt.bit_rate / 1000) + ' kbps' : 'unknown'));
+
+  if (video) {
+    console.log('');
+    console.log(chalk.bold.yellow('  Video'));
+    console.log('    Codec:      ' + video.codec_name + (video.profile ? ` (${video.profile})` : ''));
+    console.log('    Resolution: ' + video.width + 'x' + video.height);
+    let fps = 'unknown';
+    try { fps = (eval(video.r_frame_rate)).toFixed(2); } catch {}
+    console.log('    FPS:        ' + fps);
+    if (video.bit_rate) console.log('    Bitrate:    ' + Math.round(video.bit_rate / 1000) + ' kbps');
+    if (video.pix_fmt) console.log('    Pixel Fmt:  ' + video.pix_fmt);
+  }
+
+  if (audio) {
+    console.log('');
+    console.log(chalk.bold.green('  Audio'));
+    console.log('    Codec:      ' + audio.codec_name);
+    console.log('    Sample:     ' + (audio.sample_rate ? audio.sample_rate + ' Hz' : 'unknown'));
+    console.log('    Channels:   ' + (audio.channels || 'unknown'));
+    if (audio.bit_rate) console.log('    Bitrate:    ' + Math.round(audio.bit_rate / 1000) + ' kbps');
+  }
+  console.log('');
+}
+
+module.exports = info;

package/src/commands/merge.js

@@ -0,0 +1,30 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, formatBytes } = require('../utils/ffmpeg');
+
+async function merge(files, opts) {
+  if (!files || files.length < 2) { console.error(chalk.red('  ✗ Need at least 2 files to merge')); process.exit(1); }
+
+  const output = opts.output || 'merged-output.mp4';
+  const listFile = `/tmp/mpx-merge-${Date.now()}.txt`;
+
+  // Create concat list
+  const content = files.map(f => `file '${path.resolve(f)}'`).join('\n');
+  fs.writeFileSync(listFile, content);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🔗 Merging ') + files.length + ' files');
+  files.forEach(f => console.log(chalk.dim('     • ') + path.basename(f)));
+
+  await run(['-f', 'concat', '-safe', '0', '-i', listFile, '-c', 'copy', '-y', output]);
+
+  fs.unlinkSync(listFile);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = merge;

package/src/commands/resize.js

@@ -0,0 +1,26 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, formatBytes } = require('../utils/ffmpeg');
+
+async function resize(filePath, opts) {
+  const w = opts.width || -1;
+  const h = opts.height || -1;
+  if (w === -1 && h === -1) { console.error(chalk.red('  ✗ Specify --width and/or --height')); process.exit(1); }
+
+  const ext = path.extname(filePath);
+  const output = opts.output || filePath.replace(ext, `-resized${ext}`);
+  const scale = `scale=${w}:${h}:force_original_aspect_ratio=decrease`;
+
+  console.log('');
+  console.log(chalk.bold.cyan('  📐 Resizing: ') + path.basename(filePath));
+
+  await run(['-i', filePath, '-vf', scale, '-c:a', 'copy', '-y', output]);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = resize;

package/src/commands/speed.js

@@ -0,0 +1,28 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, formatBytes } = require('../utils/ffmpeg');
+
+async function speed(filePath, opts) {
+  const factor = parseFloat(opts.factor || 2);
+  if (factor <= 0 || factor > 100) { console.error(chalk.red('  ✗ Factor must be between 0.1 and 100')); process.exit(1); }
+
+  const ext = path.extname(filePath);
+  const label = factor > 1 ? `${factor}x faster` : `${(1/factor).toFixed(1)}x slower`;
+  const output = opts.output || filePath.replace(ext, `-${factor}x${ext}`);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  ⏩ Speed change: ') + path.basename(filePath) + chalk.dim(` → ${label}`));
+
+  const vFilter = `setpts=${(1/factor).toFixed(4)}*PTS`;
+  const aFilter = `atempo=${Math.min(Math.max(factor, 0.5), 2.0)}`;
+
+  await run(['-i', filePath, '-vf', vFilter, '-af', aFilter, '-y', output]);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = speed;

package/src/commands/thumbnail.js

@@ -0,0 +1,40 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { probe, run, formatBytes } = require('../utils/ffmpeg');
+
+async function thumbnail(filePath, opts) {
+  const output = opts.output || filePath.replace(path.extname(filePath), '-thumbnails.jpg');
+  const cols = opts.cols || 4;
+  const rows = opts.rows || 4;
+
+  const data = probe(filePath);
+  const duration = parseFloat(data.format.duration || 0);
+  const total = cols * rows;
+  const interval = duration / (total + 1);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  🖼️  Generating thumbnail grid: ') + path.basename(filePath));
+  console.log(chalk.dim(`     ${cols}x${rows} = ${total} frames`));
+
+  // Generate individual frames then tile
+  const tmpDir = `/tmp/mpx-thumbs-${Date.now()}`;
+  fs.mkdirSync(tmpDir, { recursive: true });
+
+  await run(['-i', filePath, '-vf', `fps=1/${interval.toFixed(2)},scale=320:-1`, '-frames:v', String(total), `${tmpDir}/frame_%03d.jpg`]);
+
+  // Use ffmpeg tile filter for grid
+  await run(['-i', `${tmpDir}/frame_%03d.jpg`, '-vf', `tile=${cols}x${rows}`, '-frames:v', '1', '-y', output]);
+
+  // Cleanup
+  const files = fs.readdirSync(tmpDir);
+  files.forEach(f => fs.unlinkSync(path.join(tmpDir, f)));
+  fs.rmdirSync(tmpDir);
+
+  const newSize = fs.statSync(output).size;
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = thumbnail;

package/src/commands/trim.js

@@ -0,0 +1,42 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, parseTime, formatTime, formatBytes } = require('../utils/ffmpeg');
+
+async function trim(filePath, opts) {
+  const start = parseTime(opts.start);
+  const end = parseTime(opts.end);
+  const duration = opts.duration ? parseTime(opts.duration) : null;
+
+  if (start === null && end === null && duration === null) {
+    console.error(chalk.red('  ✗ Specify --start and/or --end (or --duration)'));
+    console.error(chalk.dim('    Example: mpx-video trim video.mp4 --start 0:30 --end 1:00'));
+    process.exit(1);
+  }
+
+  const ext = path.extname(filePath);
+  const output = opts.output || filePath.replace(ext, `-trimmed${ext}`);
+
+  console.log('');
+  console.log(chalk.bold.cyan('  ✂️  Trimming: ') + path.basename(filePath));
+  if (start !== null) console.log(chalk.dim('     Start: ') + formatTime(start));
+  if (end !== null) console.log(chalk.dim('     End:   ') + formatTime(end));
+  if (duration !== null) console.log(chalk.dim('     Duration: ') + formatTime(duration));
+
+  const args = ['-i', filePath];
+  if (start !== null) args.push('-ss', String(start));
+  if (end !== null) args.push('-to', String(end));
+  if (duration !== null && end === null) args.push('-t', String(duration));
+  args.push('-c', 'copy', '-y', output);
+
+  const t0 = Date.now();
+  await run(args);
+  const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done') + chalk.dim(` in ${elapsed}s`));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = trim;

package/src/commands/watermark.js

@@ -0,0 +1,36 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { run, formatBytes } = require('../utils/ffmpeg');
+
+async function watermark(filePath, opts) {
+  const text = opts.text;
+  if (!text) { console.error(chalk.red('  ✗ Specify --text "Your watermark"')); process.exit(1); }
+
+  const ext = path.extname(filePath);
+  const output = opts.output || filePath.replace(ext, `-watermarked${ext}`);
+  const pos = opts.position || 'bottom-right';
+
+  const posMap = {
+    'top-left': 'x=20:y=20',
+    'top-right': 'x=w-tw-20:y=20',
+    'bottom-left': 'x=20:y=h-th-20',
+    'bottom-right': 'x=w-tw-20:y=h-th-20',
+    'center': 'x=(w-tw)/2:y=(h-th)/2',
+  };
+  const xy = posMap[pos] || posMap['bottom-right'];
+  const fontSize = opts.fontSize || 24;
+
+  console.log('');
+  console.log(chalk.bold.cyan('  💧 Adding watermark: ') + `"${text}"`);
+
+  const drawtext = `drawtext=text='${text.replace(/'/g, "\\'")}':fontsize=${fontSize}:fontcolor=white@0.7:${xy}`;
+  await run(['-i', filePath, '-vf', drawtext, '-c:a', 'copy', '-y', output]);
+  const newSize = fs.statSync(output).size;
+
+  console.log(chalk.bold.green('  ✓ Done'));
+  console.log(chalk.dim('     Output: ') + output + chalk.dim(` (${formatBytes(newSize)})`));
+  console.log('');
+}
+
+module.exports = watermark;

package/src/license.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LICENSE_DIR = path.join(os.homedir(), '.mpx-video');
+const LICENSE_FILE = path.join(LICENSE_DIR, 'license.json');
+const USAGE_FILE = path.join(LICENSE_DIR, 'usage.json');
+const FREE_DAILY_LIMIT = 5;
+
+function ensureDir() {
+  if (!fs.existsSync(LICENSE_DIR)) fs.mkdirSync(LICENSE_DIR, { recursive: true });
+}
+
+function getLicense() {
+  ensureDir();
+  try {
+    if (fs.existsSync(LICENSE_FILE)) {
+      const data = JSON.parse(fs.readFileSync(LICENSE_FILE, 'utf8'));
+      if (data.key && data.key.startsWith('MPX-PRO-')) {
+        return { tier: 'pro', key: data.key, email: data.email || null };
+      }
+    }
+  } catch (err) {}
+  return { tier: 'free', key: null, email: null };
+}
+
+function activateLicense(key, email = null) {
+  ensureDir();
+  if (!key.startsWith('MPX-PRO-')) throw new Error('Invalid license key format. Pro keys start with MPX-PRO-');
+  fs.writeFileSync(LICENSE_FILE, JSON.stringify({ key, email, activatedAt: new Date().toISOString() }, null, 2));
+  return { success: true, tier: 'pro' };
+}
+
+function checkRateLimit() {
+  const license = getLicense();
+  if (license.tier === 'pro') return { allowed: true, remaining: -1 };
+  ensureDir();
+  let usage = { ops: [], lastReset: null };
+  try { if (fs.existsSync(USAGE_FILE)) usage = JSON.parse(fs.readFileSync(USAGE_FILE, 'utf8')); } catch (err) {}
+  const today = new Date().toISOString().split('T')[0];
+  if (usage.lastReset !== today) usage = { ops: [], lastReset: today };
+  const todayOps = usage.ops.filter(s => s.startsWith(today));
+  if (todayOps.length >= FREE_DAILY_LIMIT) return { allowed: false, remaining: 0 };
+  return { allowed: true, remaining: FREE_DAILY_LIMIT - todayOps.length };
+}
+
+function recordUsage() {
+  const license = getLicense();
+  if (license.tier === 'pro') return;
+  ensureDir();
+  let usage = { ops: [], lastReset: null };
+  try { if (fs.existsSync(USAGE_FILE)) usage = JSON.parse(fs.readFileSync(USAGE_FILE, 'utf8')); } catch (err) {}
+  const today = new Date().toISOString().split('T')[0];
+  if (usage.lastReset !== today) usage = { ops: [], lastReset: today };
+  usage.ops.push(new Date().toISOString());
+  if (usage.ops.length > 20) usage.ops = usage.ops.slice(-20);
+  fs.writeFileSync(USAGE_FILE, JSON.stringify(usage, null, 2));
+}
+
+function deactivateLicense() {
+  if (fs.existsSync(LICENSE_FILE)) fs.unlinkSync(LICENSE_FILE);
+  return { success: true, tier: 'free' };
+}
+
+module.exports = { getLicense, activateLicense, deactivateLicense, checkRateLimit, recordUsage, FREE_DAILY_LIMIT };

package/src/utils/ffmpeg.js

@@ -0,0 +1,82 @@
+const { execSync, spawn } = require('child_process');
+
+function checkFfmpeg() {
+  try { execSync('ffmpeg -version', { stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+function checkFfprobe() {
+  try { execSync('ffprobe -version', { stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+function requireFfmpeg() {
+  if (!checkFfmpeg() || !checkFfprobe()) {
+    console.error('ffmpeg and ffprobe are required but not found.\n');
+    console.error('Install ffmpeg:');
+    console.error('  macOS:   brew install ffmpeg');
+    console.error('  Ubuntu:  sudo apt install ffmpeg');
+    console.error('  Windows: winget install ffmpeg');
+    console.error('  Other:   https://ffmpeg.org/download.html');
+    process.exit(1);
+  }
+}
+
+function probe(filePath) {
+  try {
+    const raw = execSync(
+      `ffprobe -v quiet -print_format json -show_format -show_streams "${filePath}"`,
+      { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }
+    );
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to probe file: ${filePath}`);
+  }
+}
+
+function run(args, { onProgress } = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ffmpeg', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    proc.stderr.on('data', d => {
+      stderr += d.toString();
+      if (onProgress) {
+        const match = d.toString().match(/time=(\d+):(\d+):(\d+\.\d+)/);
+        if (match) {
+          const secs = parseInt(match[1]) * 3600 + parseInt(match[2]) * 60 + parseFloat(match[3]);
+          onProgress(secs);
+        }
+      }
+    });
+    proc.on('close', code => {
+      if (code === 0) resolve(stderr);
+      else reject(new Error(`ffmpeg exited with code ${code}\n${stderr.slice(-500)}`));
+    });
+    proc.on('error', reject);
+  });
+}
+
+function parseTime(str) {
+  if (!str) return null;
+  // Accept: 90, 90s, 1:30, 01:30, 1:01:30, 01:01:30
+  if (/^\d+(\.\d+)?s?$/.test(str)) return parseFloat(str);
+  const parts = str.split(':').map(Number);
+  if (parts.length === 2) return parts[0] * 60 + parts[1];
+  if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  return null;
+}
+
+function formatTime(secs) {
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor((secs % 3600) / 60);
+  const s = (secs % 60).toFixed(1);
+  if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(4, '0')}`;
+  return `${m}:${String(s).padStart(4, '0')}`;
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return bytes + ' B';
+  if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
+  if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
+  return (bytes / 1073741824).toFixed(2) + ' GB';
+}
+
+module.exports = { checkFfmpeg, checkFfprobe, requireFfmpeg, probe, run, parseTime, formatTime, formatBytes };