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

package/bin/cli.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.mjs'

package/dist/cli.mjs

@@ -0,0 +1,653 @@
+import process from 'node:process';
+import { select as select$2, isCancel, intro } from '@clack/prompts';
+import ansis, { cyan, bold, gray, yellow } from 'ansis';
+import { defineCommand, runMain } from 'citty';
+import path from 'node:path';
+import { fileToBase64, base64ToFile } from '#/core/base64';
+import { tryCatch as tryCatch$1, ValidationError, FileError, CryptoError } from '#/utils/errors';
+import { createCommandContext, buildOutputPath, getPassword, loadArchive } from '#/utils/helpers';
+import { Buffer } from 'node:buffer';
+import { randomBytes, createCipheriv, pbkdf2Sync, createDecipheriv } from 'node:crypto';
+import fs from 'node:fs/promises';
+import { CRYPTO_ALGORITHM } from '#/config/crypto-algorithm';
+import { mkdirSync, accessSync } from 'node:fs';
+import path$1 from 'node:path/posix';
+import { logger as logger$1 } from '#/utils/logger';
+import { AUDIO_FORMATS } from '#/config/audio-formats';
+import { DEFAULT_CONFIG } from '#/config/defaults';
+import { extractAudio } from '#/core/extract';
+import { select as select$1 } from '#/utils/prompts';
+
+const base64 = defineCommand({
+  meta: {
+    name: "base64",
+    description: "\u5C06\u6587\u4EF6\u8F6C\u6362\u4E3A Base64 JSON"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "\u8F93\u51FA\u76EE\u5F55"
+    }
+  },
+  async run({ args, rawArgs }) {
+    const typedArgs = args;
+    const ctx = createCommandContext(rawArgs);
+    ctx.showIntro();
+    tryCatch$1(async () => {
+      const inputPath = await ctx.getInput(typedArgs.input, {
+        message: "\u8BF7\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84",
+        placeholder: "file.txt"
+      });
+      const outputDir = await ctx.getOutput(typedArgs.output, {
+        defaultDir: path.dirname(inputPath)
+      });
+      const outputPath = buildOutputPath(inputPath, outputDir, "base64.json");
+      const loading = ctx.loading("\u6B63\u5728\u8F6C\u6362");
+      const archiveData = await fileToBase64(inputPath, outputPath);
+      loading.close(
+        `\u6587\u4EF6\u5DF2\u4FDD\u5B58\u5230: ${cyan(outputPath)}, \u5171\u8BA1 ${bold.gray((archiveData.file.size / 1024).toFixed(2))} KB`
+      );
+      ctx.showOutro("\u{1F4E6} \u8F6C\u6362\u5B8C\u6210");
+    });
+  }
+});
+
+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;
+}
+const bufferToBase64 = (data) => data.toString("base64");
+const base64ToBuffer = (data) => Buffer.from(data, "base64");
+
+function nowUTC8() {
+  const now = /* @__PURE__ */ new Date();
+  const utc8Time = new Date(now.getTime() + 8 * 60 * 60 * 1e3);
+  return utc8Time.toISOString().replace("T", " ").substring(0, 19);
+}
+
+const deriveKey = (password, salt) => {
+  return pbkdf2Sync(password, salt, 1e5, 32, "sha256");
+};
+async function encrypt$1(filePath, outputPath, options) {
+  if (!filePath) {
+    throw new ValidationError("\u6587\u4EF6\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A", "filePath");
+  }
+  if (!outputPath) {
+    throw new ValidationError("\u8F93\u51FA\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A", "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(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, filePath);
+    }
+    if (error.code === "EACCES") {
+      throw new FileError(`\u6CA1\u6709\u6587\u4EF6\u8BBF\u95EE\u6743\u9650: ${filePath}`, filePath);
+    }
+    throw new CryptoError(`\u52A0\u5BC6\u5931\u8D25: ${error.message}`, "encrypt");
+  }
+}
+async function decrypt$1(archiveData, outputDir = ".", options) {
+  if (!archiveData) {
+    throw new ValidationError("\u5F52\u6863\u6570\u636E\u4E0D\u80FD\u4E3A\u7A7A", "archiveData");
+  }
+  if (!archiveData.file?.encrypted) {
+    throw new ValidationError("\u5F52\u6863\u6570\u636E\u683C\u5F0F\u9519\u8BEF", "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("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6587\u4EF6\u5DF2\u635F\u574F");
+    }
+    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(`\u6CA1\u6709\u76EE\u5F55\u5199\u5165\u6743\u9650: ${outputDir}`, outputDir);
+    }
+    throw new CryptoError(`\u89E3\u5BC6\u5931\u8D25: ${error.message}`, "decrypt");
+  }
+}
+
+const logger = {
+  success: (msg) => console.log(`${ansis.green("\u2713")}  ${msg}`),
+  error: (msg) => console.log(`${ansis.red("\u2717")}  ${msg}`),
+  info: (msg) => console.log(`${ansis.cyan("\u2139")}  ${msg}`),
+  warn: (msg) => console.log(`${ansis.yellow("\u26A0")}  ${msg}`),
+  dim: (msg) => console.log(`${ansis.dim("\u2022")}  ${msg}`)
+};
+
+class AppError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AppError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+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(`\u8BE6\u60C5: ${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(`\u672A\u77E5\u9519\u8BEF: ${String(error)}`);
+  }
+  process.exit(1);
+}
+
+const decrypt = defineCommand({
+  meta: {
+    name: "decrypt",
+    description: "\u89E3\u5BC6\u6587\u4EF6"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "\u52A0\u5BC6\u6587\u4EF6 (*.crypto.json)",
+      required: true
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "\u8F93\u51FA\u76EE\u5F55"
+    },
+    password: {
+      type: "string",
+      alias: "p",
+      description: "\u89E3\u5BC6\u5BC6\u7801"
+    }
+  },
+  async run({ args, rawArgs }) {
+    const typedArgs = args;
+    const ctx = createCommandContext(rawArgs);
+    ctx.showIntro();
+    tryCatch(async () => {
+      const inputPath = await ctx.getInput(typedArgs.input, {
+        message: "\u8BF7\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84",
+        placeholder: "*.crypto.json",
+        validateExtension: ".crypto.json"
+      });
+      const outputDir = await ctx.getOutput(typedArgs.output, {
+        defaultDir: path.dirname(inputPath)
+      });
+      const password = await getPassword(typedArgs.password);
+      const loading = ctx.loading("\u6B63\u5728\u89E3\u5BC6");
+      const archiveData = await loadArchive(inputPath, "crypto");
+      const outputPath = await decrypt$1(archiveData, outputDir, {
+        password
+      });
+      loading.close(`\u6587\u4EF6\u5DF2\u89E3\u5BC6\u5230: ${cyan(outputPath)}`);
+      ctx.showOutro("\u{1F513} \u89E3\u5BC6\u5B8C\u6210");
+    });
+  }
+});
+
+const encrypt = defineCommand({
+  meta: {
+    name: "encrypt",
+    description: "\u52A0\u5BC6\u6587\u4EF6"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "\u6587\u4EF6\u8DEF\u5F84",
+      required: true
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "\u8F93\u51FA\u76EE\u5F55"
+    },
+    password: {
+      type: "string",
+      alias: "p",
+      description: "\u52A0\u5BC6\u5BC6\u94A5"
+    }
+  },
+  async run({ args, rawArgs }) {
+    const typedArgs = args;
+    const ctx = createCommandContext(rawArgs);
+    ctx.showIntro();
+    tryCatch(async () => {
+      const inputPath = await ctx.getInput(typedArgs.input, {
+        message: "\u8BF7\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84",
+        placeholder: "file.txt"
+      });
+      const outputDir = await ctx.getOutput(typedArgs.output, {
+        defaultDir: path$1.dirname(inputPath)
+      });
+      const password = await getPassword(typedArgs.password);
+      console.log(gray("\u2502"));
+      logger$1.warn(yellow("\u8BF7\u59A5\u5584\u4FDD\u7BA1\u5BC6\u7801\uFF0C\u4E22\u5931\u540E\u65E0\u6CD5\u6062\u590D\u6587\u4EF6\uFF01"));
+      const outputPath = buildOutputPath(inputPath, outputDir, "crypto.json");
+      const loading = ctx.loading("\u6B63\u5728\u52A0\u5BC6");
+      const archiveData = await encrypt$1(inputPath, outputPath, {
+        password
+      });
+      loading.close(
+        `\u6587\u4EF6\u5DF2\u52A0\u5BC6\u5230: ${cyan(outputPath)}, \u5171\u8BA1 ${bold.gray((archiveData.file.size / 1024).toFixed(2))} KB`
+      );
+      ctx.showOutro("\u{1F510} \u52A0\u5BC6\u5B8C\u6210");
+    });
+  }
+});
+
+const restore = defineCommand({
+  meta: {
+    name: "restore",
+    description: "\u4ECE Base64 JSON \u6062\u590D\u6587\u4EF6"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Base64 \u6587\u4EF6 (*.base64.json)"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "\u8F93\u51FA\u76EE\u5F55"
+    }
+  },
+  async run({ args, rawArgs }) {
+    const typedArgs = args;
+    const ctx = createCommandContext(rawArgs);
+    ctx.showIntro();
+    tryCatch$1(async () => {
+      const inputPath = await ctx.getInput(typedArgs.input, {
+        message: "\u8BF7\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84",
+        placeholder: "*.base64.json",
+        validateExtension: "base64.json"
+      });
+      const outputDir = await ctx.getOutput(typedArgs.output, {
+        defaultDir: path.dirname(inputPath)
+      });
+      const loading = ctx.loading("\u6B63\u5728\u6062\u590D");
+      const archiveData = await loadArchive(inputPath, "base64");
+      const restoredPath = await base64ToFile(archiveData, outputDir);
+      loading.close(
+        `\u6587\u4EF6\u5DF2\u6062\u590D\u5230: ${cyan(restoredPath)}, \u539F\u59CB\u521B\u5EFA\u65F6\u95F4 ${bold.gray(archiveData.createdAt)}`
+      );
+      ctx.showOutro("\u{1F504} \u6062\u590D\u5B8C\u6210");
+    });
+  }
+});
+
+const FORMAT_OPTIONS = [
+  { value: "mp3", label: "MP3 (\u901A\u7528)", hint: "128k-320k" },
+  { value: "aac", label: "AAC/M4A (Apple)", hint: "128k-256k" },
+  { value: "flac", label: "FLAC (\u65E0\u635F)", hint: "\u53EF\u538B\u7F29" },
+  { value: "alac", label: "ALAC (Apple \u65E0\u635F)", hint: "iTunes/iOS" },
+  { value: "wav", label: "WAV (\u65E0\u635F)", hint: "\u6700\u5927" }
+];
+const getQualityOptions = (format) => {
+  if (format === "flac") {
+    return [
+      { value: "low", label: "\u5FEB\u901F", hint: "\u7EA7\u522B 0" },
+      { value: "medium", label: "\u5E73\u8861 (\u63A8\u8350)", hint: "\u7EA7\u522B 5" },
+      { value: "high", label: "\u6700\u5927\u538B\u7F29", hint: "\u7EA7\u522B 8" }
+    ];
+  }
+  const formatConfig = AUDIO_FORMATS[format];
+  return [
+    { value: "low", label: "\u4F4E", hint: formatConfig.quality.low },
+    { value: "medium", label: "\u4E2D (\u63A8\u8350)", hint: formatConfig.quality.medium },
+    { value: "high", label: "\u9AD8", hint: formatConfig.quality.high }
+  ];
+};
+const v2a = defineCommand({
+  meta: {
+    name: "video-to-audio",
+    description: "\u4ECE\u89C6\u9891\u4E2D\u63D0\u53D6\u97F3\u9891"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "\u89C6\u9891\u6587\u4EF6\u8DEF\u5F84"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "\u8F93\u51FA\u76EE\u5F55"
+    },
+    format: {
+      type: "string",
+      alias: "f",
+      description: "\u97F3\u9891\u683C\u5F0F (mp3, aac, flac, alac, wav)"
+    },
+    quality: {
+      type: "string",
+      alias: "q",
+      description: "\u97F3\u9891\u8D28\u91CF (low, medium, high)"
+    }
+  },
+  async run({ args, rawArgs }) {
+    const typedArgs = args;
+    const ctx = createCommandContext(rawArgs);
+    ctx.showIntro();
+    tryCatch$1(async () => {
+      const inputPath = await ctx.getInput(typedArgs.input, {
+        message: "\u8BF7\u8F93\u5165\u89C6\u9891\u6587\u4EF6\u8DEF\u5F84",
+        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: "\u9009\u62E9\u97F3\u9891\u683C\u5F0F",
+          options: FORMAT_OPTIONS
+        });
+      } else if (!AUDIO_FORMATS[format]) {
+        logger$1.error(`\u4E0D\u652F\u6301\u7684\u683C\u5F0F: ${format}`);
+        logger$1.info(`\u652F\u6301\u7684\u683C\u5F0F: ${Object.keys(AUDIO_FORMATS).join(", ")}`);
+        process.exit(1);
+      }
+      const formatConfig = AUDIO_FORMATS[format];
+      let quality;
+      if (!typedArgs.quality && formatConfig.needsQuality) {
+        const message = format === "flac" ? "\u9009\u62E9\u538B\u7F29\u7EA7\u522B" : "\u9009\u62E9\u97F3\u9891\u8D28\u91CF";
+        quality = await select$1({
+          message,
+          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("\u6B63\u5728\u63D0\u53D6\u97F3\u9891 0%");
+      await extractAudio(
+        inputPath,
+        outputPath,
+        { format, quality },
+        (percent) => {
+          loading.update(`\u6B63\u5728\u63D0\u53D6\u97F3\u9891 ${percent}%`);
+        }
+      );
+      loading.close(`\u97F3\u9891\u5DF2\u63D0\u53D6\u5230: ${cyan(outputPath)}`);
+      ctx.showOutro("\u{1F3B5} \u63D0\u53D6\u5B8C\u6210");
+    });
+  }
+});
+
+const CLI_NAME = "File Kit";
+const CLI_VERSION = "1.0.0";
+const CLI_ALIAS = "fkt";
+
+function handleCancel(result) {
+  if (isCancel(result)) {
+    logger.error(ansis.red("\u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    process.exit(0);
+  }
+}
+async function select(options) {
+  const result = await select$2(options);
+  handleCancel(result);
+  return result;
+}
+
+const COMMAND_MAP = {
+  base64,
+  restore,
+  "video-to-audio": v2a,
+  encrypt,
+  decrypt
+};
+const INTERACTIVE_OPTIONS = [
+  {
+    value: "base64",
+    label: ansis.cyan("\u{1F4E6} \u6587\u4EF6\u8F6C Base64"),
+    hint: "\u5C06\u4EFB\u610F\u6587\u4EF6\u7F16\u7801\u4E3A Base64 JSON"
+  },
+  {
+    value: "restore",
+    label: ansis.green("\u{1F504} Base64 \u8FD8\u539F\u6587\u4EF6"),
+    hint: "\u4ECE Base64 JSON \u6062\u590D\u539F\u59CB\u6587\u4EF6"
+  },
+  {
+    value: "video-to-audio",
+    label: ansis.magenta("\u{1F3B5} \u89C6\u9891\u63D0\u53D6\u97F3\u9891"),
+    hint: "\u4ECE\u89C6\u9891\u4E2D\u63D0\u53D6\u97F3\u9891\u8F68\u9053"
+  },
+  {
+    value: "encrypt",
+    label: ansis.red("\u{1F510} \u6587\u4EF6\u52A0\u5BC6"),
+    hint: "\u52A0\u5BC6\u6587\u4EF6\u5E76\u751F\u6210 Crypto JSON"
+  },
+  {
+    value: "decrypt",
+    label: ansis.green("\u{1F513} \u6587\u4EF6\u89E3\u5BC6"),
+    hint: "\u4ECE Crypto JSON \u89E3\u5BC6\u8FD8\u539F\u6587\u4EF6"
+  }
+];
+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) {
+    const excludeHelpArgs = rawArgs.filter(
+      (arg) => arg !== "--help" && arg !== "-h"
+    );
+    process.argv = excludeHelpArgs;
+  }
+}
+function showVersion() {
+  console.log(
+    ansis.cyan(`
+  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E
+  \u2502   \u{1F527} ${ansis.bold(CLI_NAME)} \xB7 ${ansis.dim(`v${CLI_VERSION}`.padEnd(9))}\u2502
+  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F
+`)
+  );
+  console.log(ansis.bold("  \u591A\u529F\u80FD\u6587\u4EF6\u5DE5\u5177\u7BB1\n"));
+  console.log(ansis.gray("  \u{1F504} Base64 \u4E92\u8F6C    \u{1F3A7} \u97F3\u9891\u63D0\u53D6    \u{1F510} \u6587\u4EF6\u52A0\u5BC6\n"));
+}
+function showHelp() {
+  console.log(
+    `${ansis.bold(`\u{1F527} ${CLI_NAME}`)}${ansis.dim(` - \u591A\u529F\u80FD\u6587\u4EF6\u5DE5\u5177\u7BB1 (${CLI_ALIAS} v${CLI_VERSION})`)}
+`
+  );
+  console.log(ansis.bold("\u7528\u6CD5:"));
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.dim("<command> [options]")}     \u6267\u884C\u6307\u5B9A\u547D\u4EE4`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-i, --interactive")}       \u8FDB\u5165\u4EA4\u4E92\u6A21\u5F0F`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-v, --version")}           \u663E\u793A\u7248\u672C\u4FE1\u606F`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-h, --help")}              \u663E\u793A\u5E2E\u52A9\u4FE1\u606F${ansis.dim("\uFF08\u9ED8\u8BA4\uFF09")}
+`
+  );
+  console.log(ansis.bold("\u547D\u4EE4:"));
+  console.log(
+    `  ${ansis.cyan("base64")}${ansis.dim("                      \u6587\u4EF6\u8F6C Base64")}`
+  );
+  console.log(
+    `  ${ansis.green("restore")}${ansis.dim("                     Base64 \u8FD8\u539F\u6587\u4EF6")}`
+  );
+  console.log(
+    `  ${ansis.magenta("video-to-audio, v2a")}${ansis.dim("         \u89C6\u9891\u63D0\u53D6\u97F3\u9891")}`
+  );
+  console.log(
+    `  ${ansis.red("encrypt")}${ansis.dim("                     \u52A0\u5BC6\u6587\u4EF6")}`
+  );
+  console.log(
+    `  ${ansis.green("decrypt")}${ansis.dim("                     \u89E3\u5BC6\u6587\u4EF6")}
+`
+  );
+  console.log(ansis.bold("\u793A\u4F8B:"));
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("base64")} ${ansis.green("file.txt")}                ${ansis.dim("\u8F6C\u6362\u6587\u4EF6\u4E3A Base64")}`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("restore")} ${ansis.green("file.json")}              ${ansis.dim("\u8FD8\u539F Base64 \u6587\u4EF6")}`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("v2a")} ${ansis.green("video.mp4")} ${ansis.blue("-f mp3")}           ${ansis.dim("\u63D0\u53D6\u89C6\u9891\u97F3\u9891\u4E3A MP3")}`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("encrypt")} ${ansis.green("secret.txt")} ${ansis.blue("-p pwd")}      ${ansis.dim("\u52A0\u5BC6\u6587\u4EF6")}`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("decrypt")} ${ansis.green("secret.json")} ${ansis.blue("-p pwd")}     ${ansis.dim("\u89E3\u5BC6\u6587\u4EF6")}`
+  );
+  console.log(
+    `  ${ansis.yellow(CLI_ALIAS)} ${ansis.cyan("-i")}                             ${ansis.dim("\u4EA4\u4E92\u5F0F\u9009\u62E9\u529F\u80FD")}
+`
+  );
+}
+async function runInteractiveMode() {
+  intro(ansis.bold.cyan(`\u{1F527} ${CLI_NAME}`));
+  const choice = await select({
+    message: "\u9009\u62E9\u529F\u80FD",
+    options: INTERACTIVE_OPTIONS
+  });
+  const selectedCommand = COMMAND_MAP[choice];
+  if (!selectedCommand) {
+    logger.error(`\u672A\u77E5\u547D\u4EE4: ${choice}`);
+    process.exit(1);
+  }
+  await selectedCommand.run?.({
+    rawArgs: ["-i"],
+    args: { _: [] },
+    cmd: {}
+  });
+}
+const main = defineCommand({
+  meta: {
+    name: "fkt",
+    version: "2.0.0",
+    description: `\u{1F527} ${CLI_NAME} - \u591A\u529F\u80FD\u6587\u4EF6\u5DE5\u5177\u7BB1`
+  },
+  args: {
+    interactive: {
+      type: "boolean",
+      alias: "i",
+      description: "\u8FDB\u5165\u4EA4\u4E92\u6A21\u5F0F",
+      default: false
+    }
+  },
+  // 子命令定义
+  subCommands: {
+    base64: () => base64,
+    restore: () => restore,
+    "video-to-audio": () => v2a,
+    v2a: () => v2a,
+    encrypt,
+    decrypt
+  },
+  // 默认行为
+  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);