1#!/usr/bin/env bun
2import { existsSync, statSync, readdirSync, unlinkSync, renameSync } from "fs";
3import { basename, dirname, extname, join, resolve } from "path";
4import { spawn } from "child_process";
5 
6type Compressor = "sips" | "cwebp" | "imagemagick" | "sharp";
7type Format = "webp" | "png" | "jpeg";
8 
9interface Options {
10  input: string;
11  output?: string;
12  format: Format;
13  quality: number;
14  keep: boolean;
15  recursive: boolean;
16  json: boolean;
17}
18 
19interface Result {
20  input: string;
21  output: string;
22  inputSize: number;
23  outputSize: number;
24  ratio: number;
25  compressor: Compressor;
26}
27 
28const SUPPORTED_EXTS = [".png", ".jpg", ".jpeg", ".webp", ".gif", ".tiff"];
29 
30async function commandExists(cmd: string): Promise<boolean> {
31  try {
32    const proc = spawn("which", [cmd], { stdio: "pipe" });
33    return new Promise((res) => {
34      proc.on("close", (code) => res(code === 0));
35      proc.on("error", () => res(false));
36    });
37  } catch {
38    return false;
39  }
40}
41 
42async function detectCompressor(format: Format): Promise<Compressor> {
43  if (format === "webp") {
44    if (await commandExists("cwebp")) return "cwebp";
45    if (await commandExists("convert")) return "imagemagick";
46    return "sharp";
47  }
48  if (process.platform === "darwin") return "sips";
49  if (await commandExists("convert")) return "imagemagick";
50  return "sharp";
51}
52 
53function runCmd(cmd: string, args: string[]): Promise<{ code: number; stderr: string }> {
54  return new Promise((res) => {
55    const proc = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
56    let stderr = "";
57    proc.stderr?.on("data", (d) => (stderr += d.toString()));
58    proc.on("close", (code) => res({ code: code ?? 1, stderr }));
59    proc.on("error", (e) => res({ code: 1, stderr: e.message }));
60  });
61}
62 
63async function compressWithSips(input: string, output: string, format: Format, quality: number): Promise<void> {
64  const fmt = format === "jpeg" ? "jpeg" : format;
65  const args = ["-s", "format", fmt, "-s", "formatOptions", String(quality), input, "--out", output];
66  const { code, stderr } = await runCmd("sips", args);
67  if (code !== 0) throw new Error(`sips failed: ${stderr}`);
68}
69 
70async function compressWithCwebp(input: string, output: string, quality: number): Promise<void> {
71  const args = ["-q", String(quality), input, "-o", output];
72  const { code, stderr } = await runCmd("cwebp", args);
73  if (code !== 0) throw new Error(`cwebp failed: ${stderr}`);
74}
75 
76async function compressWithImagemagick(input: string, output: string, quality: number): Promise<void> {
77  const args = [input, "-quality", String(quality), output];
78  const { code, stderr } = await runCmd("convert", args);
79  if (code !== 0) throw new Error(`convert failed: ${stderr}`);
80}
81 
82async function compressWithSharp(input: string, output: string, format: Format, quality: number): Promise<void> {
83  const sharp = (await import("sharp")).default;
84  let pipeline = sharp(input);
85  if (format === "webp") pipeline = pipeline.webp({ quality });
86  else if (format === "png") pipeline = pipeline.png({ quality });
87  else if (format === "jpeg") pipeline = pipeline.jpeg({ quality });
88  await pipeline.toFile(output);
89}
90 
91async function compress(
92  compressor: Compressor,
93  input: string,
94  output: string,
95  format: Format,
96  quality: number
97): Promise<void> {
98  switch (compressor) {
99    case "sips":
100      await compressWithSips(input, output, format, quality);
101      break;
102    case "cwebp":
103      if (format !== "webp") {
104        await compressWithSharp(input, output, format, quality);
105      } else {
106        await compressWithCwebp(input, output, quality);
107      }
108      break;
109    case "imagemagick":
110      await compressWithImagemagick(input, output, quality);
111      break;
112    case "sharp":
113      await compressWithSharp(input, output, format, quality);
114      break;
115  }
116}
117 
118function getOutputPath(input: string, format: Format, keep: boolean, customOutput?: string): string {
119  if (customOutput) return resolve(customOutput);
120  const dir = dirname(input);
121  const base = basename(input, extname(input));
122  const ext = format === "jpeg" ? ".jpg" : `.${format}`;
123  if (keep && extname(input).toLowerCase() === ext) {
124    return join(dir, `${base}-compressed${ext}`);
125  }
126  return join(dir, `${base}${ext}`);
127}
128 
129function formatSize(bytes: number): string {
130  if (bytes < 1024) return `${bytes}B`;
131  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}KB`;
132  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
133}
134 
135async function processFile(
136  compressor: Compressor,
137  input: string,
138  opts: Options
139): Promise<Result> {
140  const absInput = resolve(input);
141  const inputSize = statSync(absInput).size;
142  const output = getOutputPath(absInput, opts.format, opts.keep, opts.output);
143  const tempOutput = output + ".tmp";
144 
145  await compress(compressor, absInput, tempOutput, opts.format, opts.quality);
146 
147  const outputSize = statSync(tempOutput).size;
148 
149  if (!opts.keep && absInput !== output) {
150    const ext = extname(absInput);
151    const base = absInput.slice(0, -ext.length);
152    renameSync(absInput, `${base}_original${ext}`);
153  }
154  renameSync(tempOutput, output);
155 
156  return {
157    input: absInput,
158    output,
159    inputSize,
160    outputSize,
161    ratio: outputSize / inputSize,
162    compressor,
163  };
164}
165 
166function collectFiles(dir: string, recursive: boolean): string[] {
167  const files: string[] = [];
168  const entries = readdirSync(dir, { withFileTypes: true });
169  for (const entry of entries) {
170    const full = join(dir, entry.name);
171    if (entry.isDirectory() && recursive) {
172      files.push(...collectFiles(full, recursive));
173    } else if (entry.isFile() && SUPPORTED_EXTS.includes(extname(entry.name).toLowerCase())) {
174      files.push(full);
175    }
176  }
177  return files;
178}
179 
180function printHelp() {
181  console.log(`Usage: bun main.ts <input> [options]
182 
183Options:
184  -o, --output <path>   Output path
185  -f, --format <fmt>    Output format: webp, png, jpeg (default: webp)
186  -q, --quality <n>     Quality 0-100 (default: 80)
187  -k, --keep            Keep original file
188  -r, --recursive       Process directories recursively
189      --json            JSON output
190  -h, --help            Show help`);
191}
192 
193function parseArgs(args: string[]): Options | null {
194  const opts: Options = {
195    input: "",
196    format: "webp",
197    quality: 80,
198    keep: false,
199    recursive: false,
200    json: false,
201  };
202 
203  for (let i = 0; i < args.length; i++) {
204    const arg = args[i];
205    if (arg === "-h" || arg === "--help") {
206      printHelp();
207      process.exit(0);
208    } else if (arg === "-o" || arg === "--output") {
209      opts.output = args[++i];
210    } else if (arg === "-f" || arg === "--format") {
211      const fmt = args[++i]?.toLowerCase();
212      if (fmt === "webp" || fmt === "png" || fmt === "jpeg" || fmt === "jpg") {
213        opts.format = fmt === "jpg" ? "jpeg" : (fmt as Format);
214      } else {
215        console.error(`Invalid format: ${fmt}`);
216        return null;
217      }
218    } else if (arg === "-q" || arg === "--quality") {
219      const q = parseInt(args[++i], 10);
220      if (isNaN(q) || q < 0 || q > 100) {
221        console.error(`Invalid quality: ${args[i]}`);
222        return null;
223      }
224      opts.quality = q;
225    } else if (arg === "-k" || arg === "--keep") {
226      opts.keep = true;
227    } else if (arg === "-r" || arg === "--recursive") {
228      opts.recursive = true;
229    } else if (arg === "--json") {
230      opts.json = true;
231    } else if (!arg.startsWith("-") && !opts.input) {
232      opts.input = arg;
233    }
234  }
235 
236  if (!opts.input) {
237    console.error("Error: Input file or directory required");
238    printHelp();
239    return null;
240  }
241 
242  return opts;
243}
244 
245async function main() {
246  const args = process.argv.slice(2);
247  const opts = parseArgs(args);
248  if (!opts) process.exit(1);
249 
250  const input = resolve(opts.input);
251  if (!existsSync(input)) {
252    console.error(`Error: ${input} not found`);
253    process.exit(1);
254  }
255 
256  const compressor = await detectCompressor(opts.format);
257  const isDir = statSync(input).isDirectory();
258 
259  if (isDir) {
260    const files = collectFiles(input, opts.recursive);
261    if (files.length === 0) {
262      console.error("No supported images found");
263      process.exit(1);
264    }
265 
266    const results: Result[] = [];
267    for (const file of files) {
268      try {
269        const r = await processFile(compressor, file, { ...opts, output: undefined });
270        results.push(r);
271        if (!opts.json) {
272          const reduction = Math.round((1 - r.ratio) * 100);
273          console.log(`${r.input} → ${r.output} (${formatSize(r.inputSize)} → ${formatSize(r.outputSize)}, ${reduction}% reduction)`);
274        }
275      } catch (e) {
276        if (!opts.json) console.error(`Error processing ${file}: ${(e as Error).message}`);
277      }
278    }
279 
280    if (opts.json) {
281      const totalInput = results.reduce((s, r) => s + r.inputSize, 0);
282      const totalOutput = results.reduce((s, r) => s + r.outputSize, 0);
283      console.log(
284        JSON.stringify({
285          files: results,
286          summary: {
287            totalFiles: results.length,
288            totalInputSize: totalInput,
289            totalOutputSize: totalOutput,
290            ratio: totalInput > 0 ? totalOutput / totalInput : 0,
291            compressor,
292          },
293        }, null, 2)
294      );
295    } else {
296      const totalInput = results.reduce((s, r) => s + r.inputSize, 0);
297      const totalOutput = results.reduce((s, r) => s + r.outputSize, 0);
298      const reduction = Math.round((1 - totalOutput / totalInput) * 100);
299      console.log(`\nProcessed ${results.length} files: ${formatSize(totalInput)} → ${formatSize(totalOutput)} (${reduction}% reduction)`);
300    }
301  } else {
302    try {
303      const r = await processFile(compressor, input, opts);
304      if (opts.json) {
305        console.log(JSON.stringify(r, null, 2));
306      } else {
307        const reduction = Math.round((1 - r.ratio) * 100);
308        console.log(`${r.input} → ${r.output} (${formatSize(r.inputSize)} → ${formatSize(r.outputSize)}, ${reduction}% reduction)`);
309      }
310    } catch (e) {
311      console.error(`Error: ${(e as Error).message}`);
312      process.exit(1);
313    }
314  }
315}
316 
317main();
318