getwebp 1.0.0

package/README.md

@@ -0,0 +1,318 @@
+# GetWebP CLI
+
+一个命令行图片转换工具，将 JPG、PNG、BMP、WebP 批量转为 WebP 格式，支持 Free 和 Pro 两种模式。
+
+官网：[https://getwebp.com](https://getwebp.com) · 定价：[https://getwebp.com/pricing](https://getwebp.com/pricing)
+
+---
+
+## 安装
+
+### 下载二进制文件
+
+| 平台 | 下载地址 |
+|------|----------|
+| macOS Apple Silicon (M1/M2/M3) | `getwebp-macos-arm64` |
+| macOS Intel | `getwebp-macos-x64` |
+| Linux x64 | `getwebp-linux-x64` |
+| Windows x64 | `getwebp-windows-x64.exe` |
+
+从 [Releases 页面](https://getwebp.com/download) 下载对应平台的二进制文件。
+
+### macOS / Linux 安装
+
+```bash
+# 重命名并赋予执行权限
+mv getwebp-macos-arm64 getwebp   # Apple Silicon
+# mv getwebp-macos-x64 getwebp   # Intel Mac
+# mv getwebp-linux-x64 getwebp   # Linux
+
+chmod +x getwebp
+
+# 移动到 PATH 目录（需要 sudo）
+sudo mv getwebp /usr/local/bin/
+
+# 验证安装
+getwebp --version
+```
+
+### Windows 安装
+
+将 `getwebp-windows-x64.exe` 重命名为 `getwebp.exe`，然后放到任意已加入 `PATH` 的目录（如 `C:\Windows\System32`），或手动将其所在目录添加到系统环境变量 `PATH`。
+
+### macOS Gatekeeper 处理
+
+macOS 可能会阻止运行未签名的二进制文件，执行以下命令移除隔离属性：
+
+```bash
+xattr -cr getwebp
+```
+
+---
+
+## 安全验证
+
+每个 Release 都附带 SHA256 校验和文件（`*.sha256`），建议安装前验证：
+
+### macOS / Linux
+
+```bash
+# 下载二进制和校验和文件
+curl -LO https://github.com/getwebp/cli/releases/download/v2.1.0/getwebp-macos-arm64
+curl -LO https://github.com/getwebp/cli/releases/download/v2.1.0/getwebp-macos-arm64.sha256
+
+# 验证
+shasum -a 256 -c getwebp-macos-arm64.sha256
+# 输出：getwebp-macos-arm64: OK
+```
+
+### Windows (PowerShell)
+
+```powershell
+# 下载
+Invoke-WebRequest -Uri "https://github.com/getwebp/cli/releases/download/v2.1.0/getwebp-win-x64.exe" -OutFile getwebp.exe
+Invoke-WebRequest -Uri "https://github.com/getwebp/cli/releases/download/v2.1.0/getwebp-win-x64.exe.sha256" -OutFile getwebp.exe.sha256
+
+# 验证
+$expected = (Get-Content getwebp.exe.sha256).Split(' ')[0]
+$actual = (Get-FileHash getwebp.exe -Algorithm SHA256).Hash.ToLower()
+if ($expected -eq $actual) { Write-Host "✓ 验证通过" } else { Write-Host "✗ 验证失败" }
+```
+
+---
+
+## 命令用法
+
+### `getwebp convert` — 转换图片
+
+```
+getwebp convert [path] [options]
+```
+
+**选项：**
+
+| 选项 | 说明 | 默认值 |
+|------|------|--------|
+| `-i, --input <path>` | 输入目录或文件 | — |
+| `-o, --output <path>` | 输出目录 | 原地覆盖 |
+| `-q, --quality <number>` | 质量 1-100 | 80 |
+| `--concurrency <number>` | 并发处理数（Pro only） | 4 |
+| `-r, --recursive` | 递归处理子目录中的图片（Starter/Pro only） | — |
+| `--dry-run` | 预览模式，不实际转换 | — |
+| `--skip-existing` | 跳过已存在的 .webp 文件 | — |
+| `--json` | JSON 格式输出（适合 AI / CI） | — |
+
+**示例：**
+
+```bash
+# 转换单张图片
+getwebp convert photo.jpg
+
+# 转换整个目录（递归）
+getwebp convert ./images
+
+# 指定输入目录和输出目录
+getwebp convert -i ./src/images -o ./dist/images
+
+# 设置质量为 90（Pro）
+getwebp convert ./images -q 90
+
+# 预览将会转换的文件（不实际执行）
+getwebp convert ./images --dry-run
+
+# 跳过已存在的 WebP 文件
+getwebp convert ./images --skip-existing
+
+# 递归处理子目录中的图片（Starter/Pro）
+getwebp convert ./images --recursive
+
+# 并发 8 线程处理（Pro）
+getwebp convert ./images --concurrency 8
+
+# JSON 输出，适合 CI/CD 流水线
+getwebp convert ./images --json
+
+# 组合选项：高质量 + 跳过已有文件 + JSON 输出
+getwebp convert -i ./images -o ./output -q 90 --skip-existing --json
+```
+
+---
+
+### `getwebp auth` — 激活 Pro 授权
+
+```bash
+getwebp auth <license-key>
+```
+
+**示例：**
+
+```bash
+# 使用许可证 Key 激活 Pro
+getwebp auth XXXX-XXXX-XXXX-XXXX
+
+# 激活成功后会显示账号信息和到期时间
+```
+
+购买 Pro 许可证请访问：[https://getwebp.com/pricing](https://getwebp.com/pricing)
+
+---
+
+### `getwebp status` — 查看授权状态
+
+```bash
+# 查看当前激活状态、许可证信息和到期时间
+getwebp status
+
+# 以 JSON 格式输出（适合脚本解析）
+getwebp status --json
+```
+
+---
+
+### `getwebp logout` — 退出登录
+
+```bash
+# 清除本地存储的许可证信息
+getwebp logout
+```
+
+---
+
+## JSON 输出格式参考
+
+所有命令均支持 `--json` 参数，适用于 AI Agent 和 CI/CD 脚本。
+
+**成功响应**（`success: true`）：
+```json
+{ "success": true, "data": { ... } }
+```
+
+**错误响应**（`success: false`）：
+```json
+{ "success": false, "status": "error", "error": "<error-code>", "message": "<human-readable>" }
+```
+
+**常见错误码：**
+
+| error 字段 | 含义 | 是否可重试 |
+|------------|------|-----------|
+| `missing_input` | 未指定输入路径 | — |
+| `network_unreachable` | 无法连接服务器 | ✅ |
+| `not_activated` | 未激活 Pro 许可证 | — |
+| `device_not_found` | 设备未找到（可能已解绑） | — |
+| `invalid_token` | Token 无效或已过期 | — |
+| `unknown_error` | 未知错误 | ✅ |
+
+**convert 成功示例：**
+```json
+{ "status": "success", "total": 3, "success": 3, "failed": 0, "results": [...] }
+```
+
+**convert 错误示例（缺少路径）：**
+```json
+{ "success": false, "status": "error", "error": "missing_input", "message": "Please specify an input path" }
+```
+
+> 注意：`getwebp logout --json` 在脚本中使用时请同时加 `--force`，否则会等待交互式确认。
+
+---
+
+## 退出码
+
+| 退出码 | 含义 |
+|--------|------|
+| `0` | 成功 |
+| `1` | 失败（详见 stderr 或 JSON 的 `error` 字段） |
+
+使用 `--json` 模式时，通过 `error` 字段区分可重试错误（如 `network_unreachable`）和永久性错误（如 `missing_input`、`not_activated`）。
+
+---
+
+## Free vs Pro
+
+| 功能 | Free | Pro |
+|------|:----:|:---:|
+| 每次最多处理张数 | 10 张 | 无限制 |
+| 处理速度 | 每张等待 3 秒 | 无限制 |
+| 并发处理 | ❌ | ✅（最多 4 并发） |
+| 递归目录（`-r`） | ❌ | ✅ |
+| 自定义质量（`-q`） | ✅ | ✅ |
+| JSON 输出（`--json`） | ✅ | ✅ |
+
+升级 Pro：[https://getwebp.com/pricing](https://getwebp.com/pricing)
+
+---
+
+## FAQ
+
+**Q：支持哪些图片格式？**
+
+A：支持 JPG、PNG、BMP、WebP 作为输入格式，统一输出为 WebP。
+
+---
+
+**Q：macOS 提示"无法打开，因为无法验证开发者"怎么办？**
+
+A：在终端执行以下命令移除隔离属性，然后重试：
+
+```bash
+xattr -cr getwebp
+```
+
+---
+
+**Q：如何激活 Pro？**
+
+A：在 [getwebp.com/pricing](https://getwebp.com/pricing) 购买许可证后，运行：
+
+```bash
+getwebp auth <你的许可证 Key>
+```
+
+激活成功后即可解锁所有 Pro 功能。
+
+---
+
+**Q：Free 模式有什么限制？**
+
+A：Free 模式每次最多转换 10 张图片，且每张图片处理前会等待 3 秒。不支持并发处理和递归子目录。升级 Pro 可解锁全部功能。
+
+---
+
+**Q：如何在 CI/CD 流水线中使用？**
+
+A：使用 `--json` 参数可以获得结构化的 JSON 输出，方便脚本解析：
+
+```bash
+getwebp convert ./images --json
+```
+
+配合 Pro 许可证，可以在 CI 环境中批量处理大量图片，无数量和速度限制。
+
+---
+
+**Q：支持退款吗？**
+
+A：购买后如有问题，请联系 [getwebp.com](https://getwebp.com/contact) 客服，我们提供合理的退款支持。
+
+---
+
+**Q：许可证可以在多台机器上使用吗？**
+
+A：许可证与设备绑定，具体设备数量限制请参考购买页面的套餐说明：[https://getwebp.com/pricing](https://getwebp.com/pricing)
+
+---
+
+**Q：如何查看当前版本？**
+
+```bash
+getwebp --version
+```
+
+---
+
+## 版本
+
+当前版本：**2.1.0**
+
+查看更新日志：[https://getwebp.com/changelog](https://getwebp.com/changelog)

package/dist/index.js

@@ -0,0 +1,927 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { cac } from "cac";
+import chalk2 from "chalk";
+
+// src/core/license.ts
+import jwt from "jsonwebtoken";
+
+// src/core/config.ts
+import Conf from "conf";
+import { machineIdSync } from "node-machine-id";
+import crypto from "node:crypto";
+import os from "node:os";
+function getMachineKey() {
+  try {
+    const id = machineIdSync();
+    return crypto.createHash("sha256").update(id).digest("hex");
+  } catch {
+    process.stderr.write(
+      "warn: Could not read machine ID, falling back to hostname.\n      Token may become invalid if hostname changes.\n"
+    );
+    return crypto.createHash("sha256").update(`${os.hostname()}:${os.userInfo().username}`).digest("hex");
+  }
+}
+var store = new Conf({
+  projectName: "getwebp",
+  encryptionKey: getMachineKey(),
+  ...process.env.GETWEBP_CONFIG_DIR ? { cwd: process.env.GETWEBP_CONFIG_DIR } : {}
+});
+function getConfig() {
+  return store.store;
+}
+function saveConfig(data) {
+  for (const [key, value] of Object.entries(data)) {
+    if (value === void 0) {
+      store.delete(key);
+    } else {
+      store.set(key, value);
+    }
+  }
+}
+
+// src/core/device.ts
+import { machineId } from "node-machine-id";
+import crypto2 from "node:crypto";
+async function getDeviceId() {
+  const id = await machineId();
+  return crypto2.createHash("sha256").update(id).digest("hex");
+}
+
+// src/core/constants.ts
+import os2 from "node:os";
+var FREE_TIER = {
+  FILE_LIMIT: 10,
+  DELAY_MS: 3e3
+};
+var DEFAULTS = {
+  QUALITY: 80,
+  CONCURRENCY: Math.max(1, os2.cpus().length - 1)
+};
+var NETWORK = {
+  HEARTBEAT_TIMEOUT_MS: 3e3,
+  API_TIMEOUT_MS: 5e3,
+  DRAIN_TIMEOUT_MS: 3e3
+};
+
+// src/core/heartbeat.ts
+var _promise = null;
+var API_BASE_URL = process.env.API_BASE_URL ?? "https://api.getwebp.com";
+function pingHeartbeat(token) {
+  const p = fetch(`${API_BASE_URL}/v1/ping`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    signal: AbortSignal.timeout(NETWORK.HEARTBEAT_TIMEOUT_MS)
+  }).then(async (res) => {
+    if (res.status === 401 || res.status === 403) {
+      try {
+        saveConfig({ token: void 0 });
+      } catch {
+      }
+    }
+  }).catch(() => {
+  }).finally(() => {
+    if (_promise === p) _promise = null;
+  });
+  _promise = p;
+}
+function drainHeartbeat() {
+  if (!_promise) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, NETWORK.DRAIN_TIMEOUT_MS);
+    _promise.then(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+// src/core/license.ts
+var API_BASE_URL2 = process.env.API_BASE_URL ?? "https://api.getwebp.com";
+function getPublicKey() {
+  const key = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz41vwWfBT+qVpqXGz7sL\nzev2A4XL6Kp62fYM1vgzUUvZMfmKY9tMa2FYgasmh+l/J+5wa310ZZV9kp4cxhKc\nGC+lgTTL/sfauyzEjtY3ZDsYON0LOA6TPGYwIppsnmgYT5PS8lIsDL1gTaaskfoy\nTz3blsLS73DX6duqJxXLZxUlXrq9OdjQj9C8OYovNXgXDCc6miexDo70TCi0oHQq\n0tpKTngmAoGsGodK+7d2Etan5n8JjCQ6LnF+g8la1k1gwcyLLaTrK3cy3fGP4gAL\nDdmkyd8ELpUrebBTRtpE9Fyk979Qs4gwghx6ecpRgd3WT354/414s6K4OsElyTyT\npwIDAQAB\n-----END PUBLIC KEY-----\n";
+  if (!key) throw new Error("JWT_PUBLIC_KEY was not injected at build time");
+  return key;
+}
+async function activate(licenseKey) {
+  try {
+    const deviceId = await getDeviceId();
+    const res = await fetch(`${API_BASE_URL2}/v1/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ licenseKey, deviceId })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      return { success: false, error: body.error ?? body.message ?? `HTTP ${res.status}` };
+    }
+    const data = await res.json().catch(() => null);
+    const token = data?.token;
+    if (!token) return { success: false, error: "Unexpected response format from server" };
+    verifyToken(token);
+    saveConfig({ token });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function checkLicense() {
+  const config = getConfig();
+  if (!config?.token) return { valid: false, plan: "free" };
+  try {
+    const payload = verifyToken(config.token);
+    pingHeartbeat(config.token);
+    const exp = typeof payload === "object" && payload !== null && "exp" in payload ? payload.exp : void 0;
+    const rawPlan = typeof payload === "object" && payload !== null && "plan" in payload ? String(payload.plan) : "pro";
+    const plan = rawPlan === "starter" ? "starter" : "pro";
+    return {
+      valid: true,
+      plan,
+      expiresAt: exp ? new Date(exp * 1e3) : void 0
+    };
+  } catch (err) {
+    if (err instanceof Error && err.name === "TokenExpiredError") {
+      return { valid: false, plan: "free", expired: true };
+    }
+    if (err instanceof Error && err.message.includes("JWT_PUBLIC_KEY")) {
+      process.stderr.write("warn: JWT public key not found. License validation skipped.\n");
+    }
+    return { valid: false, plan: "free" };
+  }
+}
+async function fetchStatus() {
+  const config = getConfig();
+  if (!config?.token) return null;
+  try {
+    const res = await fetch(`${API_BASE_URL2}/v1/status`, {
+      headers: { Authorization: `Bearer ${config.token}` },
+      signal: AbortSignal.timeout(NETWORK.API_TIMEOUT_MS)
+    });
+    if (res.status === 401) {
+      try {
+        saveConfig({ token: void 0, statusCache: void 0 });
+      } catch {
+      }
+      return null;
+    }
+    if (!res.ok) return null;
+    const data = await res.json();
+    saveConfig({ statusCache: data });
+    return data;
+  } catch {
+    const cached = config.statusCache;
+    if (cached) return { ...cached, cached: true };
+    return null;
+  }
+}
+async function logout() {
+  const config = getConfig();
+  if (!config?.token) return { success: false, error: "not_activated" };
+  try {
+    const res = await fetch(`${API_BASE_URL2}/v1/unbind`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${config.token}` },
+      signal: AbortSignal.timeout(NETWORK.API_TIMEOUT_MS)
+    });
+    if (res.status === 404) return { success: false, error: "device_not_found" };
+    if (res.status === 401) return { success: false, error: "invalid_token" };
+    if (!res.ok) return { success: false, error: `HTTP ${res.status}` };
+    saveConfig({ token: void 0, statusCache: void 0 });
+    return { success: true };
+  } catch {
+    return { success: false, error: "network_unreachable" };
+  }
+}
+function verifyToken(token) {
+  return jwt.verify(token, getPublicKey(), { algorithms: ["RS256"] });
+}
+
+// src/core/exit-codes.ts
+var ExitCode = {
+  Success: 0,
+  GenericError: 1,
+  PartialFailure: 2,
+  AuthError: 3,
+  NetworkError: 4
+};
+function resolveExitCode(results) {
+  if (results.length === 0) return ExitCode.Success;
+  const hasError = results.some((r) => r.status === "error");
+  return hasError ? ExitCode.PartialFailure : ExitCode.Success;
+}
+
+// src/core/processor.ts
+import { encode as encodeWebp } from "@jsquash/webp";
+import { unlinkSync, constants as fsConstants } from "node:fs";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+import pLimit from "p-limit";
+
+// src/utils/debug.ts
+var _verbose = false;
+var _debug = false;
+function setVerbose(v) {
+  _verbose = v;
+}
+function setDebug(v) {
+  _debug = v;
+  if (v) _verbose = true;
+}
+function debugLog(...args) {
+  if (_debug) process.stderr.write("[debug] " + args.join(" ") + "\n");
+}
+
+// src/core/codecs.ts
+import { decode as decodeJpeg } from "@jsquash/jpeg";
+import { decode as decodePng } from "@jsquash/png";
+import { decode as decodeWebp } from "@jsquash/webp";
+import Bmp from "bmp-js";
+import fs from "node:fs/promises";
+import path from "node:path";
+var decoders = {
+  ".jpg": decodeJpeg,
+  ".jpeg": decodeJpeg,
+  ".png": decodePng,
+  ".webp": decodeWebp
+};
+var MAGIC_VALIDATORS = {
+  ".jpg": (b) => b[0] === 255 && b[1] === 216 && b[2] === 255,
+  ".jpeg": (b) => b[0] === 255 && b[1] === 216 && b[2] === 255,
+  ".png": (b) => b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71,
+  ".webp": (b) => b.length > 11 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80,
+  ".bmp": (b) => b[0] === 66 && b[1] === 77
+};
+var BMP_MAX_DIMENSION = 65535;
+async function decodeBmp(buffer) {
+  if (buffer.byteLength < 54) {
+    throw new Error("BMP file too small to contain a valid header");
+  }
+  const bmpWidth = buffer.readUInt32LE(18);
+  const bmpHeight = Math.abs(buffer.readInt32LE(22));
+  if (bmpWidth === 0 || bmpHeight === 0 || bmpWidth > BMP_MAX_DIMENSION || bmpHeight > BMP_MAX_DIMENSION) {
+    throw new Error(`BMP dimensions out of range: ${bmpWidth}x${bmpHeight}`);
+  }
+  const bmp = Bmp.decode(buffer);
+  const data = bmp.data;
+  for (let i = 0; i < data.length; i += 4) {
+    const tmp = data[i];
+    data[i] = data[i + 2];
+    data[i + 2] = tmp;
+  }
+  return new ImageData(new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength), bmp.width, bmp.height);
+}
+async function decodeImage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const buffer = await fs.readFile(filePath);
+  if (buffer.byteLength === 0) {
+    throw new Error(`File is empty (0 bytes): ${filePath}`);
+  }
+  const validate = MAGIC_VALIDATORS[ext];
+  if (validate && !validate(buffer)) {
+    throw new Error(`File header does not match expected ${ext} format: ${filePath}`);
+  }
+  debugLog("decode", ext, filePath);
+  if (ext === ".bmp") {
+    try {
+      return await decodeBmp(buffer);
+    } catch (err) {
+      throw new Error(`Failed to decode ${filePath} as BMP: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const decoder = decoders[ext];
+  if (!decoder) {
+    throw new Error(`Unsupported format: ${ext}`);
+  }
+  const arrayBuffer = buffer.byteOffset === 0 && buffer.byteLength === buffer.buffer.byteLength ? buffer.buffer : buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  try {
+    return await decoder(arrayBuffer);
+  } catch (err) {
+    throw new Error(`Failed to decode ${filePath} as ${ext}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+// src/core/file-scanner.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".bmp", ".webp"]);
+async function collectImageFiles(input, recursive) {
+  const lstat = await fs2.lstat(input);
+  if (lstat.isSymbolicLink()) {
+    process.stderr.write(`Warning: ${input} is a symlink, skipping
+`);
+    return [];
+  }
+  if (lstat.isFile()) return [input];
+  let entries;
+  try {
+    entries = await fs2.readdir(input, { withFileTypes: true });
+  } catch {
+    process.stderr.write(`Warning: cannot read directory ${input}, skipping
+`);
+    return [];
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  const results = [];
+  const subdirPromises = [];
+  for (const entry of entries) {
+    const fullPath = path2.join(input, entry.name);
+    if (entry.isDirectory() && recursive && !entry.isSymbolicLink()) {
+      subdirPromises.push(collectImageFiles(fullPath, recursive));
+    } else if (entry.isFile() && !entry.isSymbolicLink() && IMAGE_EXTS.has(path2.extname(entry.name).toLowerCase())) {
+      results.push(fullPath);
+    }
+  }
+  const subResults = await Promise.all(subdirPromises);
+  results.push(...subResults.flat());
+  return results.sort();
+}
+
+// src/core/wasm-init.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { init as initPngCodec } from "@jsquash/png/decode";
+import { init as initJpegDec } from "@jsquash/jpeg/decode";
+import { init as initWebpDec } from "@jsquash/webp/decode";
+import { init as initWebpEnc } from "@jsquash/webp/encode";
+var _require = createRequire(import.meta.url);
+var initialized = false;
+async function initWasm() {
+  if (initialized) return;
+  initialized = true;
+  const pngWasm = new WebAssembly.Module(readFileSync(_require.resolve("@jsquash/png/codec/pkg/squoosh_png_bg.wasm")));
+  await initPngCodec(pngWasm);
+  const jpegWasm = new WebAssembly.Module(readFileSync(_require.resolve("@jsquash/jpeg/codec/dec/mozjpeg_dec.wasm")));
+  await initJpegDec(jpegWasm);
+  const webpDecWasm = new WebAssembly.Module(readFileSync(_require.resolve("@jsquash/webp/codec/dec/webp_dec.wasm")));
+  await initWebpDec(webpDecWasm);
+  const webpEncWasm = new WebAssembly.Module(readFileSync(_require.resolve("@jsquash/webp/codec/enc/webp_enc.wasm")));
+  await initWebpEnc(webpEncWasm);
+}
+
+// src/core/processor.ts
+async function processImages(options) {
+  const { input, output, quality, plan, out } = options;
+  const isFree = plan === "free";
+  const dryRun = options.dryRun ?? false;
+  const skipExisting = options.skipExisting ?? false;
+  debugLog("processImages", input, {
+    plan,
+    concurrency: options.concurrency,
+    recursive: options.recursive,
+    dryRun,
+    skipExisting
+  });
+  try {
+    await fs3.access(input);
+  } catch {
+    throw new Error(`Path not found: ${input}`);
+  }
+  await initWasm();
+  const recursive = options.recursive ?? false;
+  const files = await collectImageFiles(input, recursive);
+  debugLog("collected", files.length, "files");
+  if (isFree && files.length > 0) {
+    out.warn("Free plan: max 10 files, 3s delay between each.");
+    out.warn("Upgrade at getwebp.com/pricing, then run: getwebp auth <your-key>");
+  }
+  const targets = isFree ? files.slice(0, FREE_TIER.FILE_LIMIT) : files;
+  const skipped = isFree ? Math.max(0, files.length - FREE_TIER.FILE_LIMIT) : 0;
+  const outputPaths = /* @__PURE__ */ new Map();
+  for (const file of targets) {
+    const dir = output ?? path3.dirname(file);
+    const outName = path3.basename(file, path3.extname(file)) + ".webp";
+    const outPath = path3.resolve(dir, outName);
+    const existing = outputPaths.get(outPath) ?? [];
+    existing.push(file);
+    outputPaths.set(outPath, existing);
+  }
+  for (const [outPath, sources] of outputPaths) {
+    if (sources.length > 1) {
+      out.warn(`Conflict: ${sources.join(", ")} all map to ${path3.basename(outPath)} \u2014 only the last processed will survive`);
+    }
+  }
+  if (!output && !dryRun) {
+    out.warn("No --output specified: converted files will be written next to source files.");
+  }
+  if (dryRun) {
+    const webpCount = targets.filter((f) => path3.extname(f).toLowerCase() === ".webp").length;
+    const nonWebpCount = targets.length - webpCount;
+    out.warn("Dry run \u2014 no files will be converted:");
+    for (const file of targets) {
+      out.warn(`  would convert: ${file}`);
+    }
+    out.warn(`Would process ${nonWebpCount} file(s) (${webpCount} already .webp, skipped)`);
+    return [];
+  }
+  if (output) {
+    await fs3.mkdir(output, { recursive: true });
+    await fs3.access(output, fsConstants.W_OK);
+  }
+  const results = [];
+  const writingFiles = /* @__PURE__ */ new Set();
+  const sigintHandler = () => {
+    for (const f of writingFiles) {
+      try {
+        unlinkSync(f);
+      } catch {
+      }
+    }
+    process.stderr.write(`
+Interrupted. ${results.length} file(s) completed, ${writingFiles.size} in-progress cleaned up.
+`);
+    process.exit(130);
+  };
+  process.once("SIGINT", sigintHandler);
+  try {
+    if (isFree) {
+      for (let i = 0; i < targets.length; i++) {
+        const file = targets[i];
+        if (i === 1) {
+          out.warn("\u23F1 3s cooldown (Starter/Pro: instant) \u2014 getwebp.com/pricing");
+          await sleep(FREE_TIER.DELAY_MS);
+        } else if (i > 1) {
+          out.warn("\u23F1 3s...");
+          await sleep(FREE_TIER.DELAY_MS);
+        }
+        debugLog("converting", file);
+        const result = await convertFile(file, output ?? path3.dirname(file), quality, out, skipExisting, writingFiles);
+        debugLog("done", file, result.status);
+        results.push(result);
+      }
+    } else {
+      const MAX_CONCURRENCY = 32;
+      const rawConcurrency = Number(options.concurrency ?? DEFAULTS.CONCURRENCY);
+      const concurrency = Number.isNaN(rawConcurrency) || rawConcurrency < 1 ? DEFAULTS.CONCURRENCY : Math.min(Math.floor(rawConcurrency), MAX_CONCURRENCY);
+      const limit = pLimit(concurrency);
+      const uniqueDirs = new Set(targets.map((file) => output ?? path3.dirname(file)));
+      await Promise.all([...uniqueDirs].map((dir) => fs3.mkdir(dir, { recursive: true })));
+      const tasks = targets.map((file) => {
+        const outputDir = output ?? path3.dirname(file);
+        return limit(async () => {
+          debugLog("converting", file);
+          const result = await convertFile(file, outputDir, quality, out, skipExisting, writingFiles);
+          debugLog("done", file, result.status);
+          return result;
+        });
+      });
+      results.push(...await Promise.all(tasks));
+    }
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+  }
+  out.summary(results, { skipped, totalFound: files.length, plan });
+  return results;
+}
+async function convertFile(filePath, outputDir, quality, out, skipExisting, writingFiles) {
+  const outName = path3.basename(filePath, path3.extname(filePath)) + ".webp";
+  const outPath = path3.join(outputDir, outName);
+  if (path3.extname(filePath).toLowerCase() === ".webp" && path3.normalize(outPath) === path3.normalize(filePath)) {
+    return { file: filePath, status: "skipped", reason: "existing" };
+  }
+  if (skipExisting) {
+    try {
+      await fs3.access(outPath);
+      return { file: filePath, status: "skipped", reason: "existing" };
+    } catch {
+    }
+  }
+  const spinner = out.startFile(filePath);
+  try {
+    const inputStat = await fs3.stat(filePath);
+    let imageData;
+    try {
+      imageData = await decodeImage(filePath);
+    } catch (err) {
+      spinner.fail();
+      const msg = err instanceof Error ? err.message : String(err);
+      return { file: filePath, status: "error", error: `Decode failed: ${msg}` };
+    }
+    let webpBuffer;
+    try {
+      webpBuffer = await encodeWebp(imageData, { quality });
+    } catch (err) {
+      spinner.fail();
+      const msg = err instanceof Error ? err.message : String(err);
+      return { file: filePath, status: "error", error: `Encode failed: ${msg}` };
+    }
+    const tmpPath = outPath + ".tmp";
+    if (process.platform === "win32" && tmpPath.length >= 260) {
+      spinner.fail();
+      return { file: filePath, status: "error", error: `Output path too long for Windows (${tmpPath.length} chars, max 260). Use a shorter output directory or enable LongPathsEnabled in Windows registry.` };
+    }
+    writingFiles.add(tmpPath);
+    await fs3.writeFile(tmpPath, new Uint8Array(webpBuffer));
+    await fs3.rename(tmpPath, outPath);
+    writingFiles.delete(tmpPath);
+    const savedRatio = 1 - webpBuffer.byteLength / inputStat.size;
+    spinner.succeed();
+    return {
+      file: filePath,
+      originalSize: inputStat.size,
+      newSize: webpBuffer.byteLength,
+      savedRatio,
+      status: "success"
+    };
+  } catch (err) {
+    writingFiles.delete(outPath + ".tmp");
+    spinner.fail();
+    const msg = err instanceof Error ? err.message : String(err);
+    return { file: filePath, status: "error", error: `Write failed: ${msg}` };
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/output/human.ts
+import ora from "ora";
+import chalk from "chalk";
+var HumanOutput = class {
+  startFile(file) {
+    const spinner = ora(`Processing ${chalk.cyan(file)}`).start();
+    return {
+      succeed: () => spinner.succeed(chalk.green(`\u2713 ${file}`)),
+      fail: () => spinner.fail(chalk.red(`\u2717 ${file}`))
+    };
+  }
+  warn(msg) {
+    process.stderr.write(chalk.yellow(`\u26A0 ${msg}`) + "\n");
+  }
+  summary(results, meta) {
+    const ok = results.filter((r) => r.status === "success");
+    const fail = results.filter((r) => r.status === "error");
+    const skipped = meta?.skipped ?? 0;
+    const totalFound = meta?.totalFound ?? results.length;
+    process.stdout.write(`
+Done: ${chalk.green(ok.length)} succeeded, ${chalk.red(fail.length)} failed
+`);
+    if (ok.length > 0) {
+      const avgSaved = ok.reduce((acc, r) => acc + r.savedRatio, 0) / ok.length;
+      const label = avgSaved >= 0 ? chalk.bold((avgSaved * 100).toFixed(1) + "%") : chalk.yellow(`-${(Math.abs(avgSaved) * 100).toFixed(1)}% (some files are larger as WebP)`);
+      process.stdout.write(`Avg saved: ${label}
+`);
+    }
+    const isFree = meta?.plan === "free";
+    if (skipped > 0) {
+      process.stdout.write(chalk.green(`
+\u2705 Processed ${results.length}/${totalFound} images (Free plan limit reached).`) + "\n");
+      process.stdout.write(chalk.cyan(`\u{1F680} ${skipped} images remaining. Free: 10 files, 3s delay | Starter: unlimited, instant ($19/mo)`) + "\n");
+      process.stdout.write(chalk.cyan(`   Upgrade at getwebp.com/pricing, then run: getwebp auth <your-key>`) + "\n");
+    } else if (isFree && results.length > 0) {
+      process.stdout.write(chalk.dim(`
+Tip: Free: 10 files, 3s delay | Starter: unlimited, instant ($19/mo) \u2014 getwebp.com/pricing`) + "\n");
+    }
+  }
+};
+
+// src/output/json.ts
+var JsonOutput = class {
+  startFile(_file) {
+    return { succeed: () => {
+    }, fail: () => {
+    } };
+  }
+  warn(msg) {
+    process.stderr.write(`warn: ${msg}
+`);
+  }
+  summary(results, meta) {
+    const skipped = meta?.skipped ?? 0;
+    const isFree = meta?.plan === "free";
+    if (skipped > 0) {
+      process.stdout.write(JSON.stringify({
+        success: true,
+        status: "partial",
+        message: `Processed ${results.length} images. Free plan limit reached (${skipped} remaining). Upgrade at getwebp.com/pricing, then run: getwebp auth <your-key>`,
+        data: {
+          processed: results.length,
+          skipped
+        },
+        upgrade: { url: "https://getwebp.com/pricing", activateCommand: "getwebp auth <your-key>" }
+      }) + "\n");
+      return;
+    }
+    const successCount = results.filter((r) => r.status === "success").length;
+    const allSuccess = results.every((r) => r.status === "success");
+    const payload = {
+      success: allSuccess,
+      status: allSuccess ? "success" : "error",
+      total: results.length,
+      successCount,
+      failedCount: results.length - successCount,
+      results: results.map(
+        (r) => r.status === "success" ? { ...r, saved: `${(r.savedRatio * 100).toFixed(1)}%` } : r
+      )
+    };
+    if (isFree && results.length > 0) {
+      payload.upgrade = { url: "https://getwebp.com/pricing", activateCommand: "getwebp auth <your-key>" };
+    }
+    process.stdout.write(JSON.stringify(payload) + "\n");
+  }
+};
+
+// src/output/index.ts
+function createOutput(jsonMode) {
+  return jsonMode ? new JsonOutput() : new HumanOutput();
+}
+
+// src/utils/exit.ts
+async function safeExit(code) {
+  await drainHeartbeat();
+  process.exit(code);
+}
+
+// src/utils/action.ts
+var _resolveAction;
+var _rejectAction;
+var actionDone = new Promise((resolve, reject) => {
+  _resolveAction = resolve;
+  _rejectAction = reject;
+});
+var _hasAction = false;
+function hasAction() {
+  return _hasAction;
+}
+function runAction(fn) {
+  _hasAction = true;
+  fn().then(_resolveAction, _rejectAction);
+}
+
+// src/utils/early-flags.ts
+function hasFlag(flag) {
+  const args = process.argv.slice(2);
+  for (const arg of args) {
+    if (arg === "--") break;
+    if (arg === flag) return true;
+  }
+  return false;
+}
+var earlyFlags = {
+  json: hasFlag("--json"),
+  verbose: hasFlag("--verbose"),
+  debug: hasFlag("--debug")
+};
+
+// src/commands/convert.ts
+function convertCommand(cli2) {
+  cli2.command("[path]", "Convert images (JPEG/PNG/BMP/WebP) to WebP format").option("-i, --input <path>", "Input file or directory path (e.g. ./images)").option("-o, --output <path>", "Output directory for converted files (default: overwrite source files in place)").option("-q, --quality <number>", "WebP quality 1\u2013100 (default: 80)", { default: void 0 }).option("--json", "Output results as JSON \u2014 useful for CI pipelines and AI agents").option("--concurrency <number>", "Number of parallel workers (default: auto, paid plans only)", { default: void 0 }).option("-r, --recursive", "Recursively process images in subdirectories").option("--dry-run", "Preview which files would be converted without actually converting them").option("--skip-existing", "Skip conversion if a .webp file already exists at the output path").action((argPath, options) => {
+    runAction(async () => {
+      const targetPath = argPath || options.input;
+      if (!targetPath) {
+        if (earlyFlags.json) {
+          process.stdout.write(JSON.stringify({ success: false, status: "error", error: "missing_input", message: "Please specify an input path" }) + "\n");
+        } else {
+          process.stderr.write("Error: Please specify an input path\n");
+          process.stderr.write("Usage: getwebp convert <path>   or   getwebp convert -i <path>\n");
+          process.stderr.write("Run 'getwebp --help' for more information.\n");
+        }
+        await safeExit(1);
+      }
+      const out = createOutput(options.json ?? false);
+      const licenseStatus = await checkLicense();
+      const rawQuality = Number(options.quality ?? 80);
+      const quality = Number.isNaN(rawQuality) ? 80 : Math.max(1, Math.min(100, rawQuality));
+      const results = await processImages({
+        input: targetPath,
+        output: options.output,
+        quality,
+        plan: licenseStatus.plan,
+        out,
+        concurrency: options.concurrency,
+        recursive: options.recursive,
+        dryRun: options.dryRun ?? false,
+        skipExisting: options.skipExisting ?? false
+      });
+      const exitCode = resolveExitCode(results);
+      if (exitCode !== 0) await safeExit(exitCode);
+    });
+  });
+}
+
+// src/commands/auth.ts
+function authCommand(cli2) {
+  cli2.command("auth <license-key>", "Activate your license key").option("--json", "Output results as JSON (for AI agents / CI)").action((licenseKey, options) => {
+    runAction(async () => {
+      const jsonMode = options.json ?? false;
+      if (!jsonMode) {
+        process.stderr.write("Verifying license...\n");
+      }
+      const result = await activate(licenseKey);
+      let planLabel = "Pro";
+      if (result.success) {
+        const status = await checkLicense();
+        const p = status.plan;
+        planLabel = p.charAt(0).toUpperCase() + p.slice(1);
+      }
+      if (jsonMode) {
+        process.stdout.write(JSON.stringify(
+          result.success ? { success: true, data: { message: `Activated \u2014 ${planLabel} plan unlocked` } } : { success: false, status: "error", error: "unknown_error", message: result.error }
+        ) + "\n");
+        await safeExit(result.success ? 0 : 1);
+      } else {
+        if (result.success) {
+          process.stderr.write(`\u2713 Activated! ${planLabel} plan unlocked.
+`);
+        } else {
+          process.stderr.write(`\u2717 Activation failed: ${result.error}
+`);
+          await safeExit(1);
+        }
+      }
+    });
+  });
+}
+
+// src/version.ts
+var VERSION = true ? "1.0.0" : await getDevVersion();
+
+// src/commands/status.ts
+function statusCommand(cli2) {
+  cli2.command("status", "Show current license and CLI status").option("--json", "Output results as JSON (for AI agents / CI)").action((options) => {
+    runAction(async () => {
+      const jsonMode = options.json ?? false;
+      const licenseCheck = await checkLicense();
+      if (!licenseCheck.valid && !licenseCheck.expired) {
+        if (jsonMode) {
+          process.stdout.write(JSON.stringify({
+            success: true,
+            data: { version: VERSION, mode: "free" }
+          }) + "\n");
+        } else {
+          process.stdout.write(`Version    : ${VERSION}
+Mode       : Free
+`);
+        }
+        return;
+      }
+      const status = await fetchStatus();
+      if (!status) {
+        if (jsonMode) {
+          process.stdout.write(JSON.stringify({
+            success: true,
+            data: {
+              version: VERSION,
+              mode: "pro",
+              cached: true,
+              expiresAt: licenseCheck.expiresAt?.toISOString()
+            }
+          }) + "\n");
+        } else {
+          process.stdout.write(
+            `Version    : ${VERSION}
+Mode       : Pro${licenseCheck.expired ? " (expired)" : ""}
+` + (licenseCheck.expiresAt ? `Expires    : ${licenseCheck.expiresAt.toISOString().slice(0, 10)}
+` : "")
+          );
+        }
+        return;
+      }
+      const plan = status.plan ?? "pro";
+      const planLabel = plan.charAt(0).toUpperCase() + plan.slice(1);
+      const modeLabel = status.cached ? `${planLabel} \xB7 cached` : planLabel;
+      const expiresLabel = status.expiresAt ? status.expiresAt.slice(0, 10) : void 0;
+      if (jsonMode) {
+        const data = {
+          version: VERSION,
+          mode: plan,
+          licenseKeySuffix: status.licenseKeySuffix,
+          expiresAt: status.expiresAt
+        };
+        if (status.cached) {
+          data.cached = true;
+        } else {
+          data.devicesUsed = status.devicesUsed;
+          data.devicesLimit = status.devicesLimit;
+        }
+        process.stdout.write(JSON.stringify({ success: true, data }) + "\n");
+      } else {
+        let out = `Version    : ${VERSION}
+`;
+        out += `Mode       : ${modeLabel}
+`;
+        out += `License    : xxxx-xxxx-xxxx-${status.licenseKeySuffix}
+`;
+        if (expiresLabel) out += `Expires    : ${expiresLabel}
+`;
+        if (!status.cached) out += `Devices    : ${status.devicesUsed} / ${status.devicesLimit} used
+`;
+        process.stdout.write(out);
+      }
+    });
+  });
+}
+
+// src/commands/logout.ts
+import * as readline from "node:readline";
+function logoutCommand(cli2) {
+  cli2.command("logout", "Unbind license from this device").option("-f, --force", "Skip confirmation prompt").option("--json", "Output results as JSON (for AI agents / CI)").action((options) => {
+    runAction(async () => {
+      const jsonMode = options.json ?? false;
+      const force = options.force ?? false;
+      if (!force && !jsonMode) {
+        const confirmed = await confirm(
+          "? Confirm unbind license from this device? This cannot be undone. (y/N) "
+        );
+        if (!confirmed) {
+          process.stderr.write("Cancelled.\n");
+          return;
+        }
+      }
+      const result = await logout();
+      if (jsonMode) {
+        if (result.success) {
+          process.stdout.write(JSON.stringify({
+            success: true,
+            data: { message: "Device unbound. Switched to Free plan." }
+          }) + "\n");
+        } else {
+          process.stdout.write(JSON.stringify({
+            success: false,
+            status: "error",
+            error: result.error ?? "unknown_error",
+            message: errorMessage(result.error)
+          }) + "\n");
+          await safeExit(1);
+        }
+      } else {
+        if (result.success) {
+          process.stderr.write("\u2713 Successfully unbound. This device is now on the Free plan.\n");
+        } else if (result.error === "network_unreachable") {
+          process.stderr.write(
+            "\u2717 Cannot reach server. Local credentials were not cleared.\n  Retry later or manually unbind via https://getwebp.com/dashboard\n"
+          );
+          await safeExit(1);
+        } else if (result.error === "not_activated") {
+          process.stderr.write("No active license found on this device.\n");
+          await safeExit(1);
+        } else {
+          process.stderr.write(`\u2717 Logout failed: ${result.error}
+`);
+          await safeExit(1);
+        }
+      }
+    });
+  });
+}
+function confirm(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+function errorMessage(error) {
+  switch (error) {
+    case "network_unreachable":
+      return "Cannot reach server. Retry later or unbind via dashboard.";
+    case "not_activated":
+      return "No active license on this device.";
+    case "device_not_found":
+      return "Device not found. It may have already been unbound.";
+    case "invalid_token":
+      return "Token is invalid or expired.";
+    default:
+      return error ?? "Unknown error";
+  }
+}
+
+// src/index.ts
+function fatalExit(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (earlyFlags.json) {
+    process.stdout.write(JSON.stringify({ status: "error", success: false, error: "unknown_error", message }) + "\n");
+  } else {
+    process.stderr.write(chalk2.red(`
+\u2717 ${message}
+`));
+  }
+  process.exit(1);
+}
+process.on("uncaughtException", fatalExit);
+process.on("unhandledRejection", fatalExit);
+process.on("beforeExit", async () => {
+  await drainHeartbeat();
+});
+var cli = cac("getwebp");
+authCommand(cli);
+statusCommand(cli);
+logoutCommand(cli);
+convertCommand(cli);
+cli.option("--verbose", "Enable verbose output");
+cli.option("--debug", "Enable debug output (implies --verbose)");
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+  process.stdout.write(`getwebp/${VERSION}
+`);
+  process.exit(0);
+}
+if (process.argv[2] === "help") {
+  process.argv[2] = "--help";
+}
+cli.help();
+cli.parse();
+setVerbose(earlyFlags.verbose);
+setDebug(earlyFlags.debug);
+if (hasAction()) await actionDone;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "getwebp",
+  "version": "1.0.0",
+  "description": "Convert images to WebP/AVIF from the command line",
+  "type": "module",
+  "bin": {
+    "getwebp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "CLI_VERSION=$(node -p \"require('./package.json').version\") bun build src/index.ts --compile --minify --define \"CLI_VERSION='$CLI_VERSION'\" --outfile release/getwebp",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --timeout 60000 tests/isolated/ && bun test --timeout 60000 tests/",
+    "test:watch": "bun test --timeout 60000 --watch"
+  },
+  "dependencies": {
+    "@jsquash/jpeg": "^1.5.0",
+    "@jsquash/png": "^3.1.0",
+    "@jsquash/webp": "^1.4.0",
+    "bmp-js": "^0.1.0",
+    "cac": "^6.7.14",
+    "chalk": "^5.3.0",
+    "conf": "^13.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "node-machine-id": "^1.1.12",
+    "ora": "^8.1.0",
+    "p-limit": "^6.2.0"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.7.0"
+  }
+}