@king-3/file-kit 1.0.0-beta.2 → 1.0.0

package/dist/cli.js

@@ -0,0 +1,1067 @@
+import process from "node:process";
+import { confirm, intro, isCancel, outro, password, select, spinner, text } from "@clack/prompts";
+import ansis, { bold, cyan, gray, yellow } from "ansis";
+import { defineCommand, runMain } from "citty";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { accessSync, existsSync, mkdirSync } from "node:fs";
+import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes } from "node:crypto";
+import path$1 from "node:path/posix";
+import ffmpegPath from "@ffmpeg-installer/ffmpeg";
+import { execa } from "execa";
+
+//#region src/utils/logger.ts
+const logger = {
+	success: (msg) => console.log(`${ansis.green("✓")}  ${msg}`),
+	error: (msg) => console.log(`${ansis.red("✗")}  ${msg}`),
+	info: (msg) => console.log(`${ansis.cyan("ℹ")}  ${msg}`),
+	warn: (msg) => console.log(`${ansis.yellow("⚠")}  ${msg}`),
+	dim: (msg) => console.log(`${ansis.dim("•")}  ${msg}`)
+};
+
+//#endregion
+//#region src/utils/errors.ts
+/**
+* 应用错误基类
+*/
+var AppError = class extends Error {
+	constructor(message, code, details) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "AppError";
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* 文件相关错误
+*/
+var FileError = class extends AppError {
+	constructor(message, filePath) {
+		super(message, "FILE_ERROR", { filePath });
+		this.filePath = filePath;
+		this.name = "FileError";
+	}
+};
+/**
+* 验证错误
+*/
+var ValidationError = class extends AppError {
+	constructor(message, field) {
+		super(message, "VALIDATION_ERROR", { field });
+		this.field = field;
+		this.name = "ValidationError";
+	}
+};
+/**
+* 转换错误
+*/
+var ConversionError = class extends AppError {
+	constructor(message, operation) {
+		super(message, "CONVERSION_ERROR", { operation });
+		this.operation = operation;
+		this.name = "ConversionError";
+	}
+};
+/**
+* 加密/解密错误
+*/
+var CryptoError = class extends AppError {
+	constructor(message, operation) {
+		super(message, "CRYPTO_ERROR", { operation });
+		this.operation = operation;
+		this.name = "CryptoError";
+	}
+};
+/**
+* FFmpeg 相关错误
+*/
+var FFmpegError = class extends AppError {
+	constructor(message, command) {
+		super(message, "FFMPEG_ERROR", { command });
+		this.command = command;
+		this.name = "FFmpegError";
+	}
+};
+/**
+* 异步操作包装器
+*/
+async function tryCatch(operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		handleError(error);
+	}
+}
+/**
+* 全局错误处理器
+*/
+function handleError(error) {
+	if (error instanceof AppError) {
+		logger.error(`[${error.code}] ${error.message}`);
+		if (error.details && Object.keys(error.details).length > 0) logger.dim(`详情: ${JSON.stringify(error.details, null, 2)}`);
+	} else if (error instanceof Error) {
+		logger.error(error.message);
+		if (process.env.DEBUG) logger.dim(error.stack || "");
+	} else logger.error(`未知错误: ${String(error)}`);
+	process.exit(1);
+}
+
+//#endregion
+//#region src/utils/file.ts
+/**
+* 检查文件是否存在
+*/
+function fileExists(targetPath) {
+	try {
+		accessSync(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 确保目录存在
+*/
+function ensureDir(targetPath) {
+	const normalizedPath = path.normalize(targetPath);
+	const dirPath = path.extname(normalizedPath) ? path.dirname(normalizedPath) : normalizedPath;
+	if (!dirPath || dirPath === "." || dirPath === path.sep) return;
+	if (!fileExists(dirPath)) mkdirSync(dirPath, { recursive: true });
+}
+/**
+* 获取文件扩展名
+*/
+function getFileExt(filePath, options) {
+	const ext = path.extname(filePath).toLowerCase();
+	return options?.withDot === false ? ext.slice(1) : ext;
+}
+/**
+* 获取文件名
+*/
+function getFileName(filePath, options) {
+	const base = path.basename(filePath);
+	return options?.withoutExt ? base.replace(path.extname(base), "") : base;
+}
+/**
+* 验证文件扩展名
+*/
+function validateExtension(filePath, expectedExt) {
+	const fileName = getFileName(filePath);
+	const normalizedExt = expectedExt.toLowerCase().replace(/^\./, "");
+	return fileName.endsWith(`.${normalizedExt}`);
+}
+/**
+* 将 Buffer 转换为 Base64 字符串
+*/
+const bufferToBase64 = (data) => data.toString("base64");
+/**
+* 将 Base64 字符串转换为 Buffer
+*/
+const base64ToBuffer = (data) => Buffer.from(data, "base64");
+
+//#endregion
+//#region src/utils/time.ts
+function nowUTC8() {
+	const now = /* @__PURE__ */ new Date();
+	return new Date(now.getTime() + 480 * 60 * 1e3).toISOString().replace("T", " ").substring(0, 19);
+}
+
+//#endregion
+//#region src/core/base64.ts
+/**
+* 将文件转换为 Base64 JSON
+*/
+async function fileToBase64(filePath, outputPath) {
+	if (!filePath) throw new ValidationError("文件路径不能为空", "filePath");
+	if (!outputPath) throw new ValidationError("输出路径不能为空", "outputPath");
+	try {
+		ensureDir(outputPath);
+		const buffer = await fs.readFile(filePath);
+		const base64 = bufferToBase64(buffer);
+		const fileName = getFileName(filePath);
+		const fileExt = getFileExt(filePath);
+		const archiveData = {
+			type: "base64",
+			createdAt: nowUTC8(),
+			file: {
+				name: fileName,
+				extension: fileExt,
+				size: buffer.length,
+				base64
+			}
+		};
+		const content = JSON.stringify(archiveData, null, 2);
+		await fs.writeFile(outputPath, content, "utf-8");
+		return archiveData;
+	} catch (error) {
+		if (error instanceof ValidationError) throw error;
+		if (error.code === "ENOENT") throw new FileError(`文件不存在: ${filePath}`, filePath);
+		if (error.code === "EACCES") throw new FileError(`没有文件访问权限: ${filePath}`, filePath);
+		throw new ConversionError(`Base64 转换失败: ${error.message}`, "fileToBase64");
+	}
+}
+/**
+* 从 Base64 JSON 恢复文件
+*/
+async function base64ToFile(archiveData, outputDir = ".") {
+	if (!archiveData) throw new ValidationError("归档数据不能为空", "archiveData");
+	if (!archiveData.file?.base64) throw new ValidationError("归档数据格式错误", "archiveData.file.base64");
+	try {
+		ensureDir(outputDir);
+		const { file } = archiveData;
+		const buffer = base64ToBuffer(file.base64);
+		const outputPath = path.join(outputDir, file.name);
+		await fs.writeFile(outputPath, buffer);
+		return outputPath;
+	} catch (error) {
+		if (error instanceof ValidationError) throw error;
+		if (error.code === "EACCES") throw new FileError(`没有目录写入权限: ${outputDir}`, outputDir);
+		throw new ConversionError(`Base64 还原失败: ${error.message}`, "base64ToFile");
+	}
+}
+
+//#endregion
+//#region src/config/defaults.ts
+const CLI_NAME = "File Kit";
+const CLI_VERSION = "1.0.0";
+const CLI_ALIAS = "fkt";
+/**
+* 默认配置
+*/
+const DEFAULT_CONFIG = {
+	output: {
+		defaultDir: "./.output",
+		useInputDirForBase64: true,
+		useInputDirForRestore: true
+	},
+	videoToAudio: {
+		defaultFormat: "mp3",
+		defaultQuality: "high"
+	}
+};
+
+//#endregion
+//#region src/utils/prompts.ts
+/**
+* 处理取消操作
+*/
+function handleCancel(result) {
+	if (isCancel(result)) {
+		logger.error(ansis.red("操作已取消"));
+		process.exit(0);
+	}
+}
+/**
+* 文本输入
+*/
+async function text$1(options) {
+	const result = await text(options);
+	handleCancel(result);
+	return result;
+}
+/**
+* 确认输入
+*/
+async function confirm$1(options) {
+	const result = await confirm(options);
+	handleCancel(result);
+	return result;
+}
+/**
+* 选择输入
+*/
+async function select$1(options) {
+	const result = await select(options);
+	handleCancel(result);
+	return result;
+}
+/**
+* 密码输入
+*/
+async function password$1(options) {
+	const result = await password(options);
+	handleCancel(result);
+	return result;
+}
+
+//#endregion
+//#region src/utils/helpers.ts
+/**
+* 创建命令上下文
+*/
+function createCommandContext(rawArgs) {
+	const isInteractive = Array.isArray(rawArgs) && rawArgs.includes("-i");
+	return {
+		isInteractive,
+		showIntro: () => {
+			if (!isInteractive) intro(bold.cyan(`🔧 ${CLI_NAME}`));
+		},
+		showOutro: (message) => {
+			outro(bold.green(message));
+		},
+		getInput: getInputPath,
+		getOutput: getOutputDir,
+		loading: (initialMessage) => {
+			const s = spinner();
+			s.start(initialMessage);
+			return {
+				update: (message) => s.message(message),
+				close: (message) => s.stop(message)
+			};
+		}
+	};
+}
+/**
+* 获取并验证输入路径
+*/
+async function getInputPath(providedPath, options) {
+	let inputPath = providedPath;
+	if (!inputPath) inputPath = await text$1({
+		message: options.message,
+		placeholder: options.placeholder,
+		validate: (value) => {
+			if (!value) return "文件路径不能为空";
+			if (!fileExists(value)) return "文件不存在";
+			if (options.validateExtension && !validateExtension(value, options.validateExtension)) return `请输入 ${options.validateExtension} 格式的文件`;
+			return options.customValidate?.(value);
+		}
+	});
+	else {
+		if (!fileExists(inputPath)) {
+			logger.error(`文件不存在: ${inputPath}`);
+			process.exit(1);
+		}
+		if (options.validateExtension && !validateExtension(inputPath, options.validateExtension)) {
+			logger.error(`请输入 ${options.validateExtension} 格式的文件`);
+			process.exit(1);
+		}
+	}
+	return inputPath;
+}
+async function getPassword(providedPwd) {
+	let userPwd = providedPwd;
+	if (!userPwd) {
+		userPwd = await password$1({
+			message: "请输入加密密码:",
+			validate: (value) => {
+				if (!value) return "密码不能为空";
+				if (value.length < 6) return "密码长度至少 6 位";
+			}
+		});
+		await password$1({
+			message: "请再次输入密码:",
+			validate: (value) => {
+				if (value !== userPwd) return "两次密码不一致";
+			}
+		});
+	} else if (typeof userPwd === "string" && userPwd.length < 6) {
+		logger.error(`'密码长度至少 6 位'`);
+		process.exit(1);
+	}
+	return userPwd;
+}
+/**
+* 获取输出目录
+*/
+async function getOutputDir(providedDir, options) {
+	if (providedDir) return providedDir;
+	if (await confirm$1({ message: `使用默认输出目录: ${cyan(options.defaultDir)}` })) return options.defaultDir;
+	return await text$1({
+		message: options.promptMessage || "请输入输出目录",
+		placeholder: options.placeholder || "./.output"
+	});
+}
+/**
+* 构建输出路径
+*/
+function buildOutputPath(inputPath, outputDir, newExt) {
+	const baseName = getFileName(inputPath, { withoutExt: !!newExt });
+	const fileName = newExt ? `${baseName}.${newExt}` : baseName;
+	return path.join(outputDir, fileName);
+}
+async function loadArchive(filePath, type) {
+	if (!filePath) throw new ValidationError("文件路径不能为空", "filePath");
+	try {
+		const content = await fs.readFile(filePath, "utf-8");
+		const data = JSON.parse(content);
+		if (!data.type || data.type !== "base64" && data.type !== "crypto") throw new ValidationError("不是有效的归档文件（type 必须是 base64 或 crypto）", "archiveData.type");
+		if (data.type !== type) throw new ValidationError(`期望的归档类型是 ${type}，但实际是 ${data.type}`, "archiveData.type");
+		if (type === "base64") {
+			const base64Data = data;
+			if (!base64Data.file?.base64) throw new ValidationError("Base64 归档文件缺少 base64 数据", "archiveData.file.base64");
+			return base64Data;
+		} else {
+			const cryptoData = data;
+			for (const field of [
+				"iv",
+				"authTag",
+				"salt",
+				"encrypted"
+			]) if (!cryptoData.file?.[field]) throw new ValidationError(`加密归档文件缺少 ${field} 数据`, `archiveData.file.${field}`);
+			return cryptoData;
+		}
+	} catch (error) {
+		if (error instanceof ValidationError) throw error;
+		if (error.code === "ENOENT") throw new FileError(`归档文件不存在: ${filePath}`, filePath);
+		if (error instanceof SyntaxError) throw new ValidationError("归档文件 JSON 格式错误", "json");
+		throw new AppError(`加载归档失败: ${error.message}`, "loadArchive");
+	}
+}
+
+//#endregion
+//#region src/commands/base64.ts
+var base64_default = defineCommand({
+	meta: {
+		name: "base64",
+		description: "将文件转换为 Base64 JSON"
+	},
+	args: {
+		input: {
+			type: "positional",
+			description: "输入文件路径"
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "输出目录"
+		}
+	},
+	async run({ args, rawArgs }) {
+		const typedArgs = args;
+		const ctx = createCommandContext(rawArgs);
+		ctx.showIntro();
+		tryCatch(async () => {
+			const inputPath = await ctx.getInput(typedArgs.input, {
+				message: "请输入文件路径",
+				placeholder: "file.txt"
+			});
+			const outputPath = buildOutputPath(inputPath, await ctx.getOutput(typedArgs.output, { defaultDir: path.dirname(inputPath) }), "base64.json");
+			const loading = ctx.loading("正在转换");
+			const archiveData = await fileToBase64(inputPath, outputPath);
+			loading.close(`文件已保存到: ${cyan(outputPath)}, 共计 ${bold.gray((archiveData.file.size / 1024).toFixed(2))} KB`);
+			ctx.showOutro("📦 转换完成");
+		});
+	}
+});
+
+//#endregion
+//#region src/config/crypto-algorithm.ts
+const CRYPTO_ALGORITHM = {
+	name: "aes-256-gcm",
+	ivLength: 16,
+	saltLength: 32,
+	iterations: 1e5
+};
+
+//#endregion
+//#region src/core/crypto.ts
+/**
+* 从密码派生密钥
+*/
+const deriveKey = (password$2, salt) => {
+	return pbkdf2Sync(password$2, salt, 1e5, 32, "sha256");
+};
+/**
+* 加密文件
+*/
+async function encrypt(filePath, outputPath, options) {
+	if (!filePath) throw new ValidationError("文件路径不能为空", "filePath");
+	if (!outputPath) throw new ValidationError("输出路径不能为空", "outputPath");
+	try {
+		ensureDir(outputPath);
+		const fileBuffer = await fs.readFile(filePath);
+		const fileName = getFileName(filePath);
+		const fileExt = getFileExt(filePath);
+		const salt = randomBytes(CRYPTO_ALGORITHM.saltLength);
+		const iv = randomBytes(CRYPTO_ALGORITHM.ivLength);
+		const key = deriveKey(options.password, salt);
+		const cipher = createCipheriv(CRYPTO_ALGORITHM.name, key, iv);
+		const encrypted = Buffer.concat([cipher.update(fileBuffer), cipher.final()]);
+		const authTag = cipher.getAuthTag();
+		const encryptedData = {
+			type: "crypto",
+			algorithm: CRYPTO_ALGORITHM.name,
+			createdAt: nowUTC8(),
+			file: {
+				name: fileName,
+				extension: fileExt,
+				size: fileBuffer.length,
+				iv: bufferToBase64(iv),
+				authTag: bufferToBase64(authTag),
+				salt: bufferToBase64(salt),
+				encrypted: bufferToBase64(encrypted)
+			}
+		};
+		const content = JSON.stringify(encryptedData, null, 2);
+		await fs.writeFile(outputPath, content, "utf-8");
+		return encryptedData;
+	} catch (error) {
+		if (error instanceof ValidationError) throw error;
+		if (error.code === "ENOENT") throw new FileError(`文件不存在: ${filePath}`, filePath);
+		if (error.code === "EACCES") throw new FileError(`没有文件访问权限: ${filePath}`, filePath);
+		throw new CryptoError(`加密失败: ${error.message}`, "encrypt");
+	}
+}
+/**
+* 解密文件
+*/
+async function decrypt(archiveData, outputDir = ".", options) {
+	if (!archiveData) throw new ValidationError("归档数据不能为空", "archiveData");
+	if (!archiveData.file?.encrypted) throw new ValidationError("归档数据格式错误", "archiveData.file.encrypted");
+	try {
+		ensureDir(outputDir);
+		const { file } = archiveData;
+		const salt = base64ToBuffer(file.salt);
+		const iv = base64ToBuffer(file.iv);
+		const authTag = base64ToBuffer(file.authTag);
+		const encrypted = base64ToBuffer(file.encrypted);
+		const key = deriveKey(options.password, salt);
+		const decipher = createDecipheriv(CRYPTO_ALGORITHM.name, key, iv);
+		decipher.setAuthTag(authTag);
+		let decrypted;
+		try {
+			decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+		} catch {
+			throw new Error("解密失败：密码错误或文件已损坏");
+		}
+		const outputPath = path.join(outputDir, file.name);
+		await fs.writeFile(outputPath, decrypted);
+		return outputPath;
+	} catch (error) {
+		if (error instanceof ValidationError) throw error;
+		if (error.code === "EACCES") throw new FileError(`没有目录写入权限: ${outputDir}`, outputDir);
+		throw new CryptoError(`解密失败: ${error.message}`, "decrypt");
+	}
+}
+
+//#endregion
+//#region src/commands/decrypt.ts
+var decrypt_default = defineCommand({
+	meta: {
+		name: "decrypt",
+		description: "解密文件"
+	},
+	args: {
+		input: {
+			type: "positional",
+			description: "加密文件 (*.crypto.json)",
+			required: true
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "输出目录"
+		},
+		password: {
+			type: "string",
+			alias: "p",
+			description: "解密密码"
+		}
+	},
+	async run({ args, rawArgs }) {
+		const typedArgs = args;
+		const ctx = createCommandContext(rawArgs);
+		ctx.showIntro();
+		tryCatch(async () => {
+			const inputPath = await ctx.getInput(typedArgs.input, {
+				message: "请输入文件路径",
+				placeholder: "*.crypto.json",
+				validateExtension: ".crypto.json"
+			});
+			const outputDir = await ctx.getOutput(typedArgs.output, { defaultDir: path.dirname(inputPath) });
+			const password$2 = await getPassword(typedArgs.password);
+			const loading = ctx.loading("正在解密");
+			const outputPath = await decrypt(await loadArchive(inputPath, "crypto"), outputDir, { password: password$2 });
+			loading.close(`文件已解密到: ${cyan(outputPath)}`);
+			ctx.showOutro("🔓 解密完成");
+		});
+	}
+});
+
+//#endregion
+//#region src/commands/encrypt.ts
+var encrypt_default = defineCommand({
+	meta: {
+		name: "encrypt",
+		description: "加密文件"
+	},
+	args: {
+		input: {
+			type: "positional",
+			description: "文件路径",
+			required: true
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "输出目录"
+		},
+		password: {
+			type: "string",
+			alias: "p",
+			description: "加密密钥"
+		}
+	},
+	async run({ args, rawArgs }) {
+		const typedArgs = args;
+		const ctx = createCommandContext(rawArgs);
+		ctx.showIntro();
+		tryCatch(async () => {
+			const inputPath = await ctx.getInput(typedArgs.input, {
+				message: "请输入文件路径",
+				placeholder: "file.txt"
+			});
+			const outputDir = await ctx.getOutput(typedArgs.output, { defaultDir: path$1.dirname(inputPath) });
+			const password$2 = await getPassword(typedArgs.password);
+			console.log(gray("│"));
+			logger.warn(yellow("请妥善保管密码，丢失后无法恢复文件！"));
+			const outputPath = buildOutputPath(inputPath, outputDir, "crypto.json");
+			const loading = ctx.loading("正在加密");
+			const archiveData = await encrypt(inputPath, outputPath, { password: password$2 });
+			loading.close(`文件已加密到: ${cyan(outputPath)}, 共计 ${bold.gray((archiveData.file.size / 1024).toFixed(2))} KB`);
+			ctx.showOutro("🔐 加密完成");
+		});
+	}
+});
+
+//#endregion
+//#region src/commands/restore.ts
+var restore_default = defineCommand({
+	meta: {
+		name: "restore",
+		description: "从 Base64 JSON 恢复文件"
+	},
+	args: {
+		input: {
+			type: "positional",
+			description: "Base64 文件 (*.base64.json)"
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "输出目录"
+		}
+	},
+	async run({ args, rawArgs }) {
+		const typedArgs = args;
+		const ctx = createCommandContext(rawArgs);
+		ctx.showIntro();
+		tryCatch(async () => {
+			const inputPath = await ctx.getInput(typedArgs.input, {
+				message: "请输入文件路径",
+				placeholder: "*.base64.json",
+				validateExtension: "base64.json"
+			});
+			const outputDir = await ctx.getOutput(typedArgs.output, { defaultDir: path.dirname(inputPath) });
+			const loading = ctx.loading("正在恢复");
+			const archiveData = await loadArchive(inputPath, "base64");
+			const restoredPath = await base64ToFile(archiveData, outputDir);
+			loading.close(`文件已恢复到: ${cyan(restoredPath)}, 原始创建时间 ${bold.gray(archiveData.createdAt)}`);
+			ctx.showOutro("🔄 恢复完成");
+		});
+	}
+});
+
+//#endregion
+//#region src/config/audio-formats.ts
+/**
+* 音频格式配置表
+*/
+const AUDIO_FORMATS = {
+	mp3: {
+		codec: "libmp3lame",
+		extension: "mp3",
+		quality: {
+			low: "128k",
+			medium: "192k",
+			high: "320k"
+		},
+		description: "MP3 (通用)",
+		needsQuality: true,
+		extraArgs: []
+	},
+	aac: {
+		codec: "aac",
+		extension: "m4a",
+		quality: {
+			low: "128k",
+			medium: "192k",
+			high: "256k"
+		},
+		description: "AAC/M4A (Apple)",
+		needsQuality: true,
+		extraArgs: ["-movflags", "+faststart"]
+	},
+	flac: {
+		codec: "flac",
+		extension: "flac",
+		quality: {
+			low: "0",
+			medium: "5",
+			high: "8"
+		},
+		description: "FLAC (无损)",
+		needsQuality: true,
+		extraArgs: ["-sample_fmt", "s16"]
+	},
+	alac: {
+		codec: "alac",
+		extension: "m4a",
+		quality: {
+			low: "0",
+			medium: "0",
+			high: "0"
+		},
+		description: "ALAC (Apple 无损)",
+		needsQuality: false,
+		extraArgs: ["-sample_fmt", "s16p"]
+	},
+	wav: {
+		codec: "pcm_s16le",
+		extension: "wav",
+		quality: {
+			low: "0",
+			medium: "0",
+			high: "0"
+		},
+		description: "WAV (无损)",
+		needsQuality: false,
+		extraArgs: []
+	}
+};
+
+//#endregion
+//#region src/core/extract.ts
+/**
+* 解析时间字符串为秒
+*/
+const parseTime = (hours, minutes, seconds) => Number.parseInt(hours) * 3600 + Number.parseInt(minutes) * 60 + Number.parseFloat(seconds);
+/**
+* 构建 FFmpeg 参数
+*/
+const buildFFmpegArgs = (filePath, outputPath, options) => {
+	const formatConfig = AUDIO_FORMATS[options.format];
+	const quality = options.quality || DEFAULT_CONFIG.videoToAudio.defaultQuality;
+	const bitrateOrQuality = options.bitrate || formatConfig.quality[quality];
+	const args = [
+		"-i",
+		filePath,
+		"-vn"
+	];
+	args.push("-ac", "2");
+	args.push("-acodec", formatConfig.codec);
+	if (options.format === "flac") args.push("-compression_level", bitrateOrQuality);
+	else if (formatConfig.needsQuality) args.push("-b:a", bitrateOrQuality);
+	if (formatConfig.extraArgs && formatConfig.extraArgs.length > 0) args.push(...formatConfig.extraArgs);
+	args.push("-y", outputPath);
+	return args;
+};
+/**
+* 从视频中提取音频
+*/
+async function extractAudio(filePath, outputPath, options, onProgress) {
+	if (!filePath) throw new ValidationError("视频文件路径不能为空", "filePath");
+	if (!outputPath) throw new ValidationError("输出路径不能为空", "outputPath");
+	if (!ffmpegPath.path || !existsSync(ffmpegPath.path)) throw new FFmpegError(`FFmpeg 未找到,路径: ${ffmpegPath.path || "undefined"}`, ffmpegPath.path);
+	if (!AUDIO_FORMATS[options.format]) throw new ValidationError(`不支持的音频格式: ${options.format}`, "format");
+	try {
+		ensureDir(outputPath);
+		const args = buildFFmpegArgs(filePath, outputPath, options);
+		const subprocess = execa(ffmpegPath.path, args);
+		if (onProgress && subprocess.stderr) {
+			let duration = 0;
+			subprocess.stderr.on("data", (data) => {
+				const text$2 = data.toString();
+				const durationMatch = text$2.match(/Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})/);
+				if (durationMatch) duration = parseTime(durationMatch[1], durationMatch[2], durationMatch[3]);
+				const timeMatch = text$2.match(/time=(\d{2}):(\d{2}):(\d{2}\.\d{2})/);
+				if (timeMatch && duration > 0) {
+					const currentTime = parseTime(timeMatch[1], timeMatch[2], timeMatch[3]);
+					onProgress(Math.min(Math.round(currentTime / duration * 100), 100));
+				}
+			});
+		}
+		await subprocess;
+		return outputPath;
+	} catch (error) {
+		if (error instanceof ValidationError) throw error;
+		if (error.message.includes("ENOENT")) throw new FFmpegError("FFmpeg 未找到,请确保已正确安装");
+		if (error.message.includes("Invalid")) throw new FFmpegError(`无效的参数: ${error.message}`);
+		const args = buildFFmpegArgs(filePath, "", options);
+		throw new FFmpegError(`FFmpeg 转换失败: ${error.message}`, args.join(" "));
+	}
+}
+
+//#endregion
+//#region src/commands/video-to-audio.ts
+const FORMAT_OPTIONS = [
+	{
+		value: "mp3",
+		label: "MP3 (通用)",
+		hint: "128k-320k"
+	},
+	{
+		value: "aac",
+		label: "AAC/M4A (Apple)",
+		hint: "128k-256k"
+	},
+	{
+		value: "flac",
+		label: "FLAC (无损)",
+		hint: "可压缩"
+	},
+	{
+		value: "alac",
+		label: "ALAC (Apple 无损)",
+		hint: "iTunes/iOS"
+	},
+	{
+		value: "wav",
+		label: "WAV (无损)",
+		hint: "最大"
+	}
+];
+const getQualityOptions = (format) => {
+	if (format === "flac") return [
+		{
+			value: "low",
+			label: "快速",
+			hint: "级别 0"
+		},
+		{
+			value: "medium",
+			label: "平衡 (推荐)",
+			hint: "级别 5"
+		},
+		{
+			value: "high",
+			label: "最大压缩",
+			hint: "级别 8"
+		}
+	];
+	const formatConfig = AUDIO_FORMATS[format];
+	return [
+		{
+			value: "low",
+			label: "低",
+			hint: formatConfig.quality.low
+		},
+		{
+			value: "medium",
+			label: "中 (推荐)",
+			hint: formatConfig.quality.medium
+		},
+		{
+			value: "high",
+			label: "高",
+			hint: formatConfig.quality.high
+		}
+	];
+};
+var video_to_audio_default = defineCommand({
+	meta: {
+		name: "video-to-audio",
+		description: "从视频中提取音频"
+	},
+	args: {
+		input: {
+			type: "positional",
+			description: "视频文件路径"
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "输出目录"
+		},
+		format: {
+			type: "string",
+			alias: "f",
+			description: "音频格式 (mp3, aac, flac, alac, wav)"
+		},
+		quality: {
+			type: "string",
+			alias: "q",
+			description: "音频质量 (low, medium, high)"
+		}
+	},
+	async run({ args, rawArgs }) {
+		const typedArgs = args;
+		const ctx = createCommandContext(rawArgs);
+		ctx.showIntro();
+		tryCatch(async () => {
+			const inputPath = await ctx.getInput(typedArgs.input, {
+				message: "请输入视频文件路径",
+				placeholder: "video.mp4"
+			});
+			const outputDir = await ctx.getOutput(typedArgs.output, { defaultDir: path.dirname(inputPath) });
+			let format = typedArgs.format;
+			if (!format) format = await select$1({
+				message: "选择音频格式",
+				options: FORMAT_OPTIONS
+			});
+			else if (!AUDIO_FORMATS[format]) {
+				logger.error(`不支持的格式: ${format}`);
+				logger.info(`支持的格式: ${Object.keys(AUDIO_FORMATS).join(", ")}`);
+				process.exit(1);
+			}
+			const formatConfig = AUDIO_FORMATS[format];
+			let quality;
+			if (!typedArgs.quality && formatConfig.needsQuality) quality = await select$1({
+				message: format === "flac" ? "选择压缩级别" : "选择音频质量",
+				options: getQualityOptions(format)
+			});
+			else if (typedArgs.quality) quality = typedArgs.quality;
+			else quality = DEFAULT_CONFIG.videoToAudio.defaultQuality;
+			const outputPath = buildOutputPath(inputPath, outputDir, formatConfig.extension);
+			const loading = ctx.loading("正在提取音频 0%");
+			await extractAudio(inputPath, outputPath, {
+				format,
+				quality
+			}, (percent) => {
+				loading.update(`正在提取音频 ${percent}%`);
+			});
+			loading.close(`音频已提取到: ${cyan(outputPath)}`);
+			ctx.showOutro("🎵 提取完成");
+		});
+	}
+});
+
+//#endregion
+//#region src/cli.ts
+const COMMAND_MAP = {
+	base64: base64_default,
+	restore: restore_default,
+	"video-to-audio": video_to_audio_default,
+	encrypt: encrypt_default,
+	decrypt: decrypt_default
+};
+const INTERACTIVE_OPTIONS = [
+	{
+		value: "base64",
+		label: ansis.cyan("📦 文件转 Base64"),
+		hint: "将任意文件编码为 Base64 JSON"
+	},
+	{
+		value: "restore",
+		label: ansis.green("🔄 Base64 还原文件"),
+		hint: "从 Base64 JSON 恢复原始文件"
+	},
+	{
+		value: "video-to-audio",
+		label: ansis.magenta("🎵 视频提取音频"),
+		hint: "从视频中提取音频轨道"
+	},
+	{
+		value: "encrypt",
+		label: ansis.red("🔐 文件加密"),
+		hint: "加密文件并生成 Crypto JSON"
+	},
+	{
+		value: "decrypt",
+		label: ansis.green("🔓 文件解密"),
+		hint: "从 Crypto JSON 解密还原文件"
+	}
+];
+const cliArgs = {
+	help: false,
+	version: false
+};
+function preprocessArgs(rawArgs) {
+	cliArgs.help = rawArgs.some((arg) => arg === "--help" || arg === "-h");
+	cliArgs.version = rawArgs.some((arg) => arg === "--version" || arg === "-v");
+	if (cliArgs.help) process.argv = rawArgs.filter((arg) => arg !== "--help" && arg !== "-h");
+}
+/**
+* 显示版本信息
+*/
+function showVersion() {
+	console.log(ansis.cyan(`
+  ╭──────────────────────────╮
+  │   🔧 ${ansis.bold(CLI_NAME)} · ${ansis.dim(`v${CLI_VERSION}`.padEnd(9))}│
+  ╰──────────────────────────╯
+`));
+	console.log(ansis.bold("  多功能文件工具箱\n"));
+	console.log(ansis.gray("  🔄 Base64 互转    🎧 音频提取    🔐 文件加密\n"));
+}
+/**
+* 显示帮助信息
+*/
+function showHelp() {
+	console.log(`${ansis.bold(`🔧 ${CLI_NAME}`)}${ansis.dim(` - 多功能文件工具箱 (${CLI_ALIAS} v${CLI_VERSION})`)}\n`);
+	console.log(ansis.bold("用法:"));
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.dim("<command> [options]")}     执行指定命令`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-i, --interactive")}       进入交互模式`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-v, --version")}           显示版本信息`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-h, --help")}              显示帮助信息${ansis.dim("（默认）")}\n`);
+	console.log(ansis.bold("命令:"));
+	console.log(`  ${ansis.cyan("base64")}${ansis.dim("                      文件转 Base64")}`);
+	console.log(`  ${ansis.green("restore")}${ansis.dim("                     Base64 还原文件")}`);
+	console.log(`  ${ansis.magenta("video-to-audio, v2a")}${ansis.dim("         视频提取音频")}`);
+	console.log(`  ${ansis.red("encrypt")}${ansis.dim("                     加密文件")}`);
+	console.log(`  ${ansis.green("decrypt")}${ansis.dim("                     解密文件")}\n`);
+	console.log(ansis.bold("示例:"));
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("base64")} ${ansis.green("file.txt")}                ${ansis.dim("转换文件为 Base64")}`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("restore")} ${ansis.green("file.json")}              ${ansis.dim("还原 Base64 文件")}`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("v2a")} ${ansis.green("video.mp4")} ${ansis.blue("-f mp3")}           ${ansis.dim("提取视频音频为 MP3")}`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("encrypt")} ${ansis.green("secret.txt")} ${ansis.blue("-p pwd")}      ${ansis.dim("加密文件")}`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("decrypt")} ${ansis.green("secret.json")} ${ansis.blue("-p pwd")}     ${ansis.dim("解密文件")}`);
+	console.log(`  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-i")}                             ${ansis.dim("交互式选择功能")}\n`);
+}
+/**
+* 交互模式
+*/
+async function runInteractiveMode() {
+	intro(ansis.bold.cyan(`🔧 ${CLI_NAME}`));
+	const choice = await select$1({
+		message: "选择功能",
+		options: INTERACTIVE_OPTIONS
+	});
+	const selectedCommand = COMMAND_MAP[choice];
+	if (!selectedCommand) {
+		logger.error(`未知命令: ${choice}`);
+		process.exit(1);
+	}
+	await selectedCommand.run?.({
+		rawArgs: ["-i"],
+		args: { _: [] },
+		cmd: {}
+	});
+}
+const main = defineCommand({
+	meta: {
+		name: "fkt",
+		version: "2.0.0",
+		description: `🔧 ${CLI_NAME} - 多功能文件工具箱`
+	},
+	args: { interactive: {
+		type: "boolean",
+		alias: "i",
+		description: "进入交互模式",
+		default: false
+	} },
+	subCommands: {
+		base64: () => base64_default,
+		restore: () => restore_default,
+		"video-to-audio": () => video_to_audio_default,
+		v2a: () => video_to_audio_default,
+		encrypt: encrypt_default,
+		decrypt: decrypt_default
+	},
+	async run({ args, rawArgs }) {
+		if (args.interactive) await runInteractiveMode();
+		if (cliArgs.version) {
+			showVersion();
+			process.exit(0);
+		}
+		if (cliArgs.help || rawArgs.length === 0) {
+			showHelp();
+			process.exit(0);
+		}
+	}
+});
+preprocessArgs(process.argv);
+runMain(main);
+
+//#endregion