lubanpng 0.1.0

package/dist/api.js

@@ -0,0 +1,146 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { ApiError } from "./errors.js";
+import { VERSION } from "./version.js";
+export const DEFAULT_API_BASE = "https://lubanpng.wizthink.cn";
+export const API_BASE_ENV = "LUBANPNG_API_BASE";
+export const USER_AGENT = `lubanpng-cli/${VERSION}`;
+export const ErrorCode = {
+    network: -1,
+    invalidParams: 1001,
+    fileTooLarge: 1004,
+    internal: 2001,
+    compressionFailed: 2002,
+    serviceUnconfigured: 2003,
+    notFound: 3003,
+    unauthorized: 4001,
+    missingCsrfHeader: 4002,
+    quotaExhausted: 4003,
+};
+const isEnvelope = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value.code === "number" &&
+    typeof value.msg === "string";
+const readNumberHeader = (read, name) => {
+    const raw = read(name);
+    if (raw === null || raw.trim() === "")
+        return null;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+export const readQuotaHeaders = (read) => ({
+    limit: readNumberHeader(read, "X-Quota-Limit"),
+    remaining: readNumberHeader(read, "X-Quota-Remaining"),
+    resetsAt: read("X-Quota-Reset"),
+});
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.apiKey = options.apiKey && options.apiKey !== "" ? options.apiKey : null;
+        this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    }
+    url(path) {
+        if (/^https?:\/\//i.test(path))
+            return path;
+        return `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    }
+    headers(json) {
+        const headers = new Headers({ Accept: "application/json", "User-Agent": USER_AGENT });
+        if (this.apiKey)
+            headers.set("Authorization", `Bearer ${this.apiKey}`);
+        if (json)
+            headers.set("Content-Type", "application/json");
+        return headers;
+    }
+    async request(method, path, options = {}) {
+        let response;
+        try {
+            response = await this.fetchImpl(this.url(path), {
+                method,
+                headers: this.headers(options.json !== undefined),
+                body: options.formData ?? (options.json === undefined ? null : JSON.stringify(options.json)),
+                signal: options.signal ?? null,
+            });
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError")
+                throw error;
+            throw new ApiError(0, ErrorCode.network, "网络错误，无法连接 LubanPNG 服务");
+        }
+        const text = await response.text();
+        const quota = readQuotaHeaders((name) => response.headers.get(name));
+        let parsed;
+        try {
+            parsed = text === "" ? null : JSON.parse(text);
+        }
+        catch {
+            throw new ApiError(response.status, ErrorCode.network, "服务返回了无法解析的响应");
+        }
+        if (!isEnvelope(parsed)) {
+            throw new ApiError(response.status, ErrorCode.network, "服务返回了无法解析的响应");
+        }
+        if (response.ok && parsed.code === 0)
+            return { data: parsed.data, quota };
+        throw new ApiError(response.status, parsed.code, parsed.msg);
+    }
+    me(signal) {
+        return this.request("GET", "/v1/me", { signal });
+    }
+    async uploadImage(filePath, signal) {
+        const data = await readFile(filePath);
+        const form = new FormData();
+        form.append("file", new Blob([new Uint8Array(data)]), basename(filePath));
+        return this.request("POST", "/v1/images/compress", { formData: form, signal });
+    }
+    taskStatus(taskId, waitSeconds, signal) {
+        return this.request("GET", `/v1/images/compress/${encodeURIComponent(taskId)}?wait=${waitSeconds}`, { signal });
+    }
+    async download(pathOrUrl, signal) {
+        let response;
+        try {
+            response = await this.fetchImpl(this.url(pathOrUrl), {
+                method: "GET",
+                headers: this.headers(false),
+                signal: signal ?? null,
+            });
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError")
+                throw error;
+            throw new ApiError(0, ErrorCode.network, "下载产物失败，网络错误");
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            try {
+                const parsed = text === "" ? null : JSON.parse(text);
+                if (isEnvelope(parsed))
+                    throw new ApiError(response.status, parsed.code, parsed.msg);
+            }
+            catch (error) {
+                if (error instanceof ApiError)
+                    throw error;
+            }
+            throw new ApiError(response.status, ErrorCode.network, "下载产物失败");
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+}
+export const describeError = (error) => {
+    if (error instanceof ApiError) {
+        if (error.code === ErrorCode.unauthorized)
+            return "API Key 无效或已吊销，请重新运行 lubanpng login";
+        if (error.code === ErrorCode.quotaExhausted)
+            return `本期额度已用尽${error.message ? `：${error.message}` : ""}`;
+        if (error.code === ErrorCode.notFound)
+            return "任务或产物不存在、已过期";
+        if (error.code === ErrorCode.network)
+            return error.message;
+        return error.message !== "" ? error.message : "请求失败";
+    }
+    if (error instanceof Error && error.message !== "")
+        return error.message;
+    return "请求失败";
+};

package/dist/args.js

@@ -0,0 +1,93 @@
+import { UsageError } from "./errors.js";
+export const DEFAULT_CONCURRENCY = 4;
+export const MAX_CONCURRENCY = 16;
+const STRING_OPTIONS = new Set(["--api-base", "--out", "--concurrency"]);
+const BOOLEAN_OPTIONS = new Set(["--in-place", "--recursive", "--help", "-h", "--version", "-v"]);
+const COMMANDS = new Set(["login", "logout", "compress", "usage"]);
+const readConcurrency = (raw) => {
+    if (!/^[1-9]\d*$/.test(raw))
+        throw new UsageError(`--concurrency 必须是正整数，收到：${raw}`);
+    const value = Number(raw);
+    if (value > MAX_CONCURRENCY) {
+        throw new UsageError(`--concurrency 最大 ${MAX_CONCURRENCY}，收到：${raw}`);
+    }
+    return value;
+};
+export const parseArgv = (argv) => {
+    const options = new Map();
+    const positionals = [];
+    let index = 0;
+    while (index < argv.length) {
+        const token = argv[index];
+        if (token === "--") {
+            positionals.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token.startsWith("-") && token !== "-") {
+            const equals = token.indexOf("=");
+            const name = equals >= 0 ? token.slice(0, equals) : token;
+            const inlineValue = equals >= 0 ? token.slice(equals + 1) : undefined;
+            if (BOOLEAN_OPTIONS.has(name)) {
+                if (inlineValue !== undefined)
+                    throw new UsageError(`选项 ${name} 不接受值`);
+                options.set(name, true);
+                index += 1;
+                continue;
+            }
+            if (STRING_OPTIONS.has(name)) {
+                const value = inlineValue ?? argv[index + 1];
+                if (value === undefined)
+                    throw new UsageError(`选项 ${name} 缺少值`);
+                options.set(name, value);
+                index += inlineValue !== undefined ? 1 : 2;
+                continue;
+            }
+            throw new UsageError(`未知选项：${name}`);
+        }
+        positionals.push(token);
+        index += 1;
+    }
+    if (options.has("--help") || options.has("-h"))
+        return { command: "help" };
+    if (options.has("--version") || options.has("-v"))
+        return { command: "version" };
+    const apiBase = options.get("--api-base");
+    const apiBaseValue = typeof apiBase === "string" ? apiBase : undefined;
+    const name = positionals[0];
+    if (name === undefined) {
+        throw new UsageError("缺少子命令。可用命令：login、logout、compress、usage");
+    }
+    if (!COMMANDS.has(name)) {
+        throw new UsageError(`未知命令：${name}。可用命令：login、logout、compress、usage`);
+    }
+    if (name === "compress") {
+        const out = options.get("--out");
+        const outValue = typeof out === "string" ? out : undefined;
+        const inPlace = options.get("--in-place") === true;
+        const recursive = options.get("--recursive") === true;
+        const concurrency = options.get("--concurrency");
+        if (inPlace && outValue !== undefined) {
+            throw new UsageError("--in-place 与 --out 不能同时使用");
+        }
+        const paths = positionals.slice(1);
+        if (paths.length === 0)
+            throw new UsageError("compress 至少需要一个文件或目录路径");
+        return {
+            command: "compress",
+            apiBase: apiBaseValue,
+            paths,
+            out: outValue,
+            inPlace,
+            recursive,
+            concurrency: typeof concurrency === "string" ? readConcurrency(concurrency) : DEFAULT_CONCURRENCY,
+        };
+    }
+    if (positionals.length > 1) {
+        throw new UsageError(`${name} 不接受多余参数：${positionals.slice(1).join(" ")}`);
+    }
+    if (name === "login")
+        return { command: "login", apiBase: apiBaseValue };
+    if (name === "logout")
+        return { command: "logout", apiBase: apiBaseValue };
+    return { command: "usage", apiBase: apiBaseValue };
+};

package/dist/commands/compress.js

@@ -0,0 +1,196 @@
+import { mkdir, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative as relativePath, resolve } from "node:path";
+import { ApiClient, describeError, } from "../api.js";
+import { API_KEY_ENV, resolveApiKey } from "../config.js";
+import { UsageError } from "../errors.js";
+import { formatBytes, formatSavings, formatSizePair, periodNoun, savingsPercent } from "../format.js";
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif"]);
+const WAIT_SECONDS = 30;
+const MAX_POLL_ROUNDS = 40;
+const SIZE_COLUMN = 9;
+const walk = async (root, current, push) => {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = join(current, entry.name);
+        if (entry.isDirectory()) {
+            await walk(root, full, push);
+        }
+        else if (entry.isFile() && IMAGE_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
+            push({ path: full, name: entry.name, relative: relativePath(root, full) });
+        }
+    }
+};
+export const collectFiles = async (inputs, recursive) => {
+    const collected = [];
+    const seen = new Set();
+    const push = (item) => {
+        const key = resolve(item.path);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        collected.push(item);
+    };
+    for (const input of inputs) {
+        let info;
+        try {
+            info = await stat(input);
+        }
+        catch {
+            throw new UsageError(`路径不存在：${input}`);
+        }
+        if (info.isDirectory()) {
+            if (!recursive)
+                throw new UsageError(`目录需要加 --recursive：${input}`);
+            await walk(input, input, push);
+        }
+        else if (info.isFile()) {
+            push({ path: input, name: basename(input), relative: basename(input) });
+        }
+        else {
+            throw new UsageError(`不支持的路径类型：${input}`);
+        }
+    }
+    return collected;
+};
+const outputPathFor = (file, options) => {
+    if (options.inPlace)
+        return file.path;
+    if (options.out !== undefined)
+        return join(options.out, file.relative);
+    const ext = extname(file.path);
+    return `${file.path.slice(0, file.path.length - ext.length)}.min${ext}`;
+};
+const writeFileAtomic = async (target, bytes) => {
+    const temp = `${target}.lubanpng-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    try {
+        await writeFile(temp, bytes);
+        await rename(temp, target);
+    }
+    catch (error) {
+        await rm(temp, { force: true }).catch(() => undefined);
+        throw error;
+    }
+};
+const assertNoTargetConflicts = (files, options) => {
+    const byTarget = new Map();
+    for (const file of files) {
+        const target = resolve(outputPathFor(file, options));
+        const sources = byTarget.get(target);
+        if (sources === undefined) {
+            byTarget.set(target, [file.path]);
+        }
+        else {
+            sources.push(file.path);
+        }
+    }
+    const conflicts = [...byTarget.entries()].filter(([, sources]) => sources.length > 1);
+    if (conflicts.length === 0)
+        return;
+    const detail = conflicts.map(([target, sources]) => `${target}（${sources.join("、")}）`).join("；");
+    throw new UsageError(`输出路径冲突：${detail}。请调整输入路径或分批压缩`);
+};
+const runPool = async (items, limit, worker) => {
+    const queue = [...items];
+    const workers = Array.from({ length: Math.min(limit, queue.length) }, async () => {
+        let next = queue.shift();
+        while (next !== undefined) {
+            await worker(next);
+            next = queue.shift();
+        }
+    });
+    await Promise.all(workers);
+};
+const waitForCompletion = async (client, taskId, onQuota) => {
+    let result = await client.taskStatus(taskId, WAIT_SECONDS);
+    onQuota(result.quota);
+    let rounds = 0;
+    while ((result.data.status === "pending" || result.data.status === "processing") &&
+        rounds < MAX_POLL_ROUNDS) {
+        rounds += 1;
+        result = await client.taskStatus(taskId, WAIT_SECONDS);
+        onQuota(result.quota);
+    }
+    return result.data;
+};
+export const compressCommand = async (context, options) => {
+    const key = await resolveApiKey(context.env);
+    if (!key)
+        throw new UsageError(`未登录，请先运行 lubanpng login 或设置 ${API_KEY_ENV}`);
+    const client = new ApiClient({ baseUrl: context.apiBase, apiKey: key });
+    const me = await client.me();
+    const period = me.data.plan.period;
+    let remaining = me.quota.remaining ?? me.data.quota.remaining;
+    const onQuota = (quota) => {
+        if (quota.remaining !== null)
+            remaining = quota.remaining;
+    };
+    const files = await collectFiles(options.paths, options.recursive);
+    if (files.length === 0) {
+        throw new UsageError("没有找到可压缩的图片（支持 PNG / JPEG / GIF）");
+    }
+    assertNoTargetConflicts(files, options);
+    const nameWidth = Math.max(...files.map((file) => file.name.length));
+    const printOutcome = (outcome) => {
+        const name = outcome.file.name.padEnd(nameWidth);
+        const pair = formatSizePair(outcome.originalSize, outcome.compressedSize);
+        const original = pair.original.padStart(SIZE_COLUMN);
+        if (!outcome.ok) {
+            context.io.write(`  ${name}  ${original} → 失败：${outcome.error ?? "压缩失败"}\n`);
+            return;
+        }
+        const compressed = pair.compressed.padStart(SIZE_COLUMN);
+        if (outcome.retained) {
+            context.io.write(`  ${name}  ${original} → ${compressed}   无收益，保留原图\n`);
+            return;
+        }
+        const percent = savingsPercent(outcome.originalSize, outcome.compressedSize);
+        context.io.write(`  ${name}  ${original} → ${compressed}   ${formatSavings(percent)}\n`);
+    };
+    const processOne = async (file) => {
+        const originalSize = (await stat(file.path)).size;
+        try {
+            const upload = await client.uploadImage(file.path);
+            onQuota(upload.quota);
+            const view = await waitForCompletion(client, upload.data.task_id, onQuota);
+            if (view.status !== "completed" || view.compressed_url === null) {
+                return { file, ok: false, retained: false, originalSize, compressedSize: 0, error: view.error_msg ?? "压缩失败" };
+            }
+            if (options.inPlace && view.compressed_size !== null && view.compressed_size >= originalSize) {
+                return { file, ok: true, retained: true, originalSize, compressedSize: view.compressed_size, error: null };
+            }
+            const bytes = await client.download(view.compressed_url);
+            const compressedSize = view.compressed_size ?? bytes.byteLength;
+            if (options.inPlace && compressedSize >= originalSize) {
+                return { file, ok: true, retained: true, originalSize, compressedSize, error: null };
+            }
+            const target = outputPathFor(file, options);
+            await mkdir(dirname(target), { recursive: true });
+            await writeFileAtomic(target, bytes);
+            return { file, ok: true, retained: false, originalSize, compressedSize, error: null };
+        }
+        catch (error) {
+            return { file, ok: false, retained: false, originalSize, compressedSize: 0, error: describeError(error) };
+        }
+    };
+    const outcomes = [];
+    await runPool(files, options.concurrency, async (file) => {
+        const outcome = await processOne(file);
+        outcomes.push(outcome);
+        printOutcome(outcome);
+    });
+    const succeeded = outcomes.filter((outcome) => outcome.ok);
+    const failed = outcomes.filter((outcome) => !outcome.ok);
+    const retained = outcomes.filter((outcome) => outcome.retained);
+    const saved = succeeded.reduce((total, outcome) => outcome.retained ? total : total + Math.max(0, outcome.originalSize - outcome.compressedSize), 0);
+    const parts = [
+        `本次 ${succeeded.length} 张`,
+        `节省 ${formatBytes(saved)}`,
+        `${periodNoun(period)}剩余 ${remaining} 次`,
+    ];
+    if (retained.length > 0)
+        parts.push(`${retained.length} 张无收益保留原图`);
+    if (failed.length > 0)
+        parts.push(`${failed.length} 张失败`);
+    context.io.write(`  ${parts.join("，")}\n`);
+    return failed.length > 0 || succeeded.length === 0 ? 1 : 0;
+};

package/dist/commands/login.js

@@ -0,0 +1,21 @@
+import { clientFor } from "../context.js";
+import { API_KEY_ENV, envApiKey, writeStoredKey } from "../config.js";
+import { UsageError } from "../errors.js";
+import { periodNoun } from "../format.js";
+export const loginCommand = async (context) => {
+    const fromEnv = envApiKey(context.env);
+    const key = fromEnv ?? (await context.io.promptSecret("  粘贴你的 API Key: ")).trim();
+    if (key === "")
+        throw new UsageError("API Key 不能为空");
+    const { data } = await clientFor(context, key).me();
+    const who = data.email ?? "当前账号";
+    const label = periodNoun(data.plan.period);
+    if (fromEnv) {
+        context.io.write(`  环境变量 ${API_KEY_ENV} 校验通过 · ${who} · ${label}剩余 ${data.quota.remaining} 次（未写入本机配置）\n`);
+    }
+    else {
+        await writeStoredKey(key, context.env);
+        context.io.write(`  已登录 ${who} · ${label}剩余 ${data.quota.remaining} 次\n`);
+    }
+    return 0;
+};

package/dist/commands/logout.js

@@ -0,0 +1,6 @@
+import { clearStoredKey } from "../config.js";
+export const logoutCommand = async (context) => {
+    const cleared = await clearStoredKey(context.env);
+    context.io.write(cleared ? "  已退出登录，本机 API Key 已清除\n" : "  本机没有保存 API Key\n");
+    return 0;
+};

package/dist/commands/usage.js

@@ -0,0 +1,15 @@
+import { API_KEY_ENV, resolveApiKey } from "../config.js";
+import { clientFor } from "../context.js";
+import { UsageError } from "../errors.js";
+import { formatResetDate, periodNoun } from "../format.js";
+export const usageCommand = async (context) => {
+    const key = await resolveApiKey(context.env);
+    if (!key)
+        throw new UsageError(`未登录，请先运行 lubanpng login 或设置 ${API_KEY_ENV}`);
+    const { data } = await clientFor(context, key).me();
+    const label = periodNoun(data.plan.period);
+    const reset = formatResetDate(data.quota.resets_at);
+    const tail = reset === "" ? "" : ` · ${reset}重置`;
+    context.io.write(`  ${data.plan.name}套餐 · ${label}已用 ${data.quota.used} / ${data.quota.limit}${tail}\n`);
+    return 0;
+};

package/dist/config.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const API_KEY_ENV = "LUBANPNG_API_KEY";
+export const configDir = (env = process.env) => {
+    if (process.platform === "win32") {
+        const appData = env.APPDATA?.trim();
+        return join(appData && appData !== "" ? appData : join(homedir(), "AppData", "Roaming"), "lubanpng");
+    }
+    const base = env.XDG_CONFIG_HOME?.trim();
+    return join(base && base !== "" ? base : join(homedir(), ".config"), "lubanpng");
+};
+export const configPath = (env = process.env) => join(configDir(env), "config.json");
+export const readStoredKey = async (env = process.env) => {
+    try {
+        const raw = await readFile(configPath(env), "utf8");
+        const parsed = JSON.parse(raw);
+        const key = typeof parsed.api_key === "string" ? parsed.api_key.trim() : "";
+        return key === "" ? null : key;
+    }
+    catch {
+        return null;
+    }
+};
+export const writeStoredKey = async (key, env = process.env) => {
+    const dir = configDir(env);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(configPath(env), `${JSON.stringify({ api_key: key }, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+};
+export const clearStoredKey = async (env = process.env) => {
+    try {
+        await rm(configPath(env));
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const envApiKey = (env = process.env) => {
+    const value = env[API_KEY_ENV]?.trim();
+    return value && value !== "" ? value : null;
+};
+export const resolveApiKey = async (env = process.env) => envApiKey(env) ?? (await readStoredKey(env));

package/dist/context.js

@@ -0,0 +1,2 @@
+import { ApiClient as Client } from "./api.js";
+export const clientFor = (context, apiKey) => new Client({ baseUrl: context.apiBase, apiKey });

package/dist/errors.js

@@ -0,0 +1,23 @@
+export class UsageError extends Error {
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = "UsageError";
+    }
+}
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = code;
+    }
+}
+export class CancelledError extends Error {
+    constructor() {
+        super("已取消");
+        this.name = "CancelledError";
+    }
+}

package/dist/format.js

@@ -0,0 +1,52 @@
+const KIB = 1024;
+const MIB = KIB * 1024;
+const GIB = MIB * 1024;
+export const unitFor = (bytes) => {
+    const safe = Math.max(0, bytes);
+    if (safe >= GIB)
+        return "GB";
+    if (safe >= MIB)
+        return "MB";
+    if (safe >= KIB)
+        return "KB";
+    return "B";
+};
+export const formatBytesIn = (bytes, unit) => {
+    const safe = Math.max(0, bytes);
+    if (unit === "B")
+        return `${Math.round(safe)} B`;
+    const divisor = unit === "GB" ? GIB : unit === "MB" ? MIB : KIB;
+    const value = safe / divisor;
+    return `${value.toFixed(value < 10 ? 2 : 0)} ${unit}`;
+};
+export const formatBytes = (bytes) => formatBytesIn(bytes, unitFor(bytes));
+export const formatSizePair = (original, compressed) => {
+    const unit = unitFor(original);
+    return {
+        original: formatBytesIn(original, unit),
+        compressed: formatBytesIn(compressed, unit),
+    };
+};
+export const savingsPercent = (original, compressed) => {
+    if (original <= 0)
+        return 0;
+    return Math.max(0, Math.round((1 - compressed / original) * 100));
+};
+export const formatSavings = (percent) => `-${percent}%`;
+const SHANGHAI = "Asia/Shanghai";
+export const formatResetDate = (iso) => {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: SHANGHAI,
+        month: "numeric",
+        day: "numeric",
+    }).formatToParts(date);
+    const month = parts.find((part) => part.type === "month")?.value ?? "";
+    const day = parts.find((part) => part.type === "day")?.value ?? "";
+    if (month === "" || day === "")
+        return "";
+    return `${Number(month)} 月 ${Number(day)} 日`;
+};
+export const periodNoun = (period) => (period === "day" ? "今日" : "本月");

package/dist/help.js

@@ -0,0 +1,33 @@
+import { DEFAULT_API_BASE, API_BASE_ENV, USER_AGENT } from "./api.js";
+import { API_KEY_ENV } from "./config.js";
+import { VERSION } from "./version.js";
+export const HELP = [
+    `lubanpng ${VERSION} — LubanPNG 命令行图片压缩`,
+    "",
+    "用法：",
+    "  lubanpng <命令> [选项]",
+    "",
+    "命令：",
+    "  login                粘贴 API Key，校验后保存到本机",
+    "  logout               清除本机保存的 API Key",
+    "  compress <路径...>   压缩文件或目录",
+    "  usage                查看套餐、本期用量与重置时间",
+    "",
+    "全局选项：",
+    `  --api-base <url>     API 地址（默认 ${DEFAULT_API_BASE}）`,
+    "  -h, --help           显示帮助",
+    "  -v, --version        显示版本",
+    "",
+    "compress 选项：",
+    "  --out <dir>          输出目录，保持输入目录结构",
+    "  --in-place           覆盖原文件",
+    "  --recursive          递归处理目录",
+    "  --concurrency <n>    并发数（默认 4，最大 16）",
+    "",
+    "环境变量：",
+    `  ${API_KEY_ENV}     API Key（优先于本机配置）`,
+    `  ${API_BASE_ENV}    API 地址覆盖`,
+    "",
+    `User-Agent: ${USER_AGENT}`,
+    "",
+].join("\n");

package/dist/io.js

@@ -0,0 +1,58 @@
+import { createInterface } from "node:readline";
+import { CancelledError } from "./errors.js";
+const readVisibleLine = (label) => new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(label, (answer) => {
+        rl.close();
+        resolve(answer);
+    });
+});
+const readHiddenLine = (label) => new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(label);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+    const cleanup = () => {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.off("data", onData);
+    };
+    const onData = (chunk) => {
+        for (const char of chunk) {
+            if (char === "\r" || char === "\n") {
+                cleanup();
+                stdout.write("\n");
+                resolve(value);
+                return;
+            }
+            if (char === "\u0003") {
+                cleanup();
+                stdout.write("\n");
+                reject(new CancelledError());
+                return;
+            }
+            if (char === "\u007f" || char === "\b") {
+                if (value !== "") {
+                    value = value.slice(0, -1);
+                    stdout.write("\b \b");
+                }
+                continue;
+            }
+            value += char;
+            stdout.write("*");
+        }
+    };
+    stdin.on("data", onData);
+});
+export const defaultIo = {
+    write: (text) => {
+        process.stdout.write(text);
+    },
+    writeError: (text) => {
+        process.stderr.write(text);
+    },
+    promptSecret: (label) => process.stdin.isTTY ? readHiddenLine(label) : readVisibleLine(label),
+};

package/dist/main.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { run } from "./run.js";
+run(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+});

package/dist/run.js

@@ -0,0 +1,61 @@
+import { API_BASE_ENV, DEFAULT_API_BASE, describeError } from "./api.js";
+import { parseArgv } from "./args.js";
+import { compressCommand } from "./commands/compress.js";
+import { loginCommand } from "./commands/login.js";
+import { logoutCommand } from "./commands/logout.js";
+import { usageCommand } from "./commands/usage.js";
+import { CancelledError, UsageError } from "./errors.js";
+import { HELP } from "./help.js";
+import { defaultIo } from "./io.js";
+import { VERSION } from "./version.js";
+export const run = async (argv, options = {}) => {
+    const env = options.env ?? process.env;
+    const io = options.io ?? defaultIo;
+    try {
+        const parsed = parseArgv(argv);
+        if (parsed.command === "help") {
+            io.write(HELP);
+            return 0;
+        }
+        if (parsed.command === "version") {
+            io.write(`${VERSION}\n`);
+            return 0;
+        }
+        const configured = parsed.apiBase ?? env[API_BASE_ENV]?.trim();
+        const context = {
+            apiBase: configured && configured !== "" ? configured : DEFAULT_API_BASE,
+            env,
+            io,
+        };
+        switch (parsed.command) {
+            case "login":
+                return await loginCommand(context);
+            case "logout":
+                return await logoutCommand(context);
+            case "usage":
+                return await usageCommand(context);
+            case "compress":
+                return await compressCommand(context, {
+                    paths: parsed.paths,
+                    out: parsed.out,
+                    inPlace: parsed.inPlace,
+                    recursive: parsed.recursive,
+                    concurrency: parsed.concurrency,
+                });
+        }
+        return 1;
+    }
+    catch (error) {
+        if (error instanceof UsageError) {
+            io.writeError(`${error.message}\n`);
+            io.writeError("运行 lubanpng --help 查看用法\n");
+            return error.exitCode;
+        }
+        if (error instanceof CancelledError) {
+            io.writeError("已取消\n");
+            return 130;
+        }
+        io.writeError(`${describeError(error)}\n`);
+        return 1;
+    }
+};

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+export const VERSION = pkg.version;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "lubanpng",
+  "version": "0.1.0",
+  "description": "LubanPNG command line image compressor",
+  "type": "module",
+  "bin": {
+    "lubanpng": "dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"require('node:fs').chmodSync('dist/main.js', 0o755)\"",
+    "test": "vitest run",
+    "lint": "tsc --noEmit -p tsconfig.json",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "lubanpng",
+    "image",
+    "compress",
+    "tinypng",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Curzibn/LubanPNG.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://lubanpng.wizthink.cn",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.2",
+    "typescript": "7.0.2",
+    "vitest": "5.0.0"
+  }
+}