@xx-in/tools 0.0.2 → 0.0.4

package/dist/cli.js

@@ -7,7 +7,7 @@ import process4 from "process";
 // package.json
 var package_default = {
   name: "@xx-in/tools",
-  version: "0.0.2",
+  version: "0.0.4",
   description: "A command-line tool to run in any system",
   license: "MIT",
   type: "module",
@@ -72,7 +72,7 @@ _xx() {
         'create:\u9012\u5F52\u521B\u5EFA\u6587\u4EF6\u6216\u76EE\u5F55'
         'format:\u4F7F\u7528 Prettier \u683C\u5F0F\u5316\u4EE3\u7801'
         'help:\u663E\u793A\u6307\u5B9A\u547D\u4EE4\u7684\u5E2E\u52A9\u4FE1\u606F'
-        'install:\u81EA\u52A8\u5206\u53D1\u90E8\u7F72\u5B89\u88C5\u5305 (\u652F\u6301 AppImage\u3001Flatpak ID\u3001tar.gz\u3001deb\u3001rpm)'
+        'install:macOS/Windows \u672C\u5730\u5DE5\u5177\u5B89\u88C5\u5668 (\u652F\u6301\u53EF\u6267\u884C\u6587\u4EF6\u3001zip\u3001tar \u5305)'
         'ip:\u672C\u5730\u6D3B\u8DC3\u7F51\u5361\u53CA\u7F51\u5173\u4FA6\u6D4B'
         'list:\u5217\u51FA\u76EE\u5F55\u4E2D\u7684\u6240\u6709\u6587\u4EF6\u548C\u76EE\u5F55\uFF08\u542B\u9690\u85CF\u9879\uFF09'
         'move:\u79FB\u52A8\u6216\u91CD\u547D\u540D\u6587\u4EF6\u53CA\u76EE\u5F55'
@@ -82,7 +82,7 @@ _xx() {
         'remove:\u5B89\u5168\u5730\u5C06\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u79FB\u81F3\u7CFB\u7EDF\u56DE\u6536\u7AD9\uFF08\u652F\u6301\u901A\u914D\u7B26\u53CA\u591A\u9009\uFF09'
         'search:\u9012\u5F52\u641C\u7D22\u76EE\u5F55\u4E0B\u5305\u542B\u6307\u5B9A\u5173\u952E\u8BCD\u7684\u6587\u4EF6\u6216\u76EE\u5F55'
         'translate:\u7EC8\u7AEF\u7FFB\u8BD1\u5DE5\u5177'
-        'uninstall:\u901A\u7528\u5E94\u7528\u5378\u8F7D\u5668\uFF08\u652F\u6301\u5305\u540D\u3001Flatpak\u3001Snap\u3001\u672C\u5730\u5305\u6216\u7EFF\u8272\u8F6F\u4EF6\uFF09'
+        'uninstall:macOS/Windows \u672C\u5730\u5DE5\u5177\u5378\u8F7D\u5668\uFF08\u79FB\u9664\u5B89\u88C5\u76EE\u5F55\u548C\u7EC8\u7AEF\u547D\u4EE4\u5165\u53E3\uFF09'
         'unzip:\u89E3\u538B ZIP \u538B\u7F29\u5305'
         'upgrade:\u81EA\u52A8\u66F4\u65B0 xx \u547D\u4EE4\u884C\u5DE5\u5177\u81F3\u6700\u65B0\u7248\u672C'
         'zip:\u81EA\u52A8\u8FC7\u6EE4\u5E76\u6253\u5305\u4E3A ZIP'
@@ -111,7 +111,7 @@ _xx() {
             'copy:\u590D\u5236\u6587\u4EF6\u6216\u76EE\u5F55\uFF08\u652F\u6301\u9012\u5F52\u590D\u5236\uFF09'
             'create:\u9012\u5F52\u521B\u5EFA\u6587\u4EF6\u6216\u76EE\u5F55'
             'format:\u4F7F\u7528 Prettier \u683C\u5F0F\u5316\u4EE3\u7801'
-            'install:\u81EA\u52A8\u5206\u53D1\u90E8\u7F72\u5B89\u88C5\u5305 (\u652F\u6301 AppImage\u3001Flatpak ID\u3001tar.gz\u3001deb\u3001rpm)'
+            'install:macOS/Windows \u672C\u5730\u5DE5\u5177\u5B89\u88C5\u5668 (\u652F\u6301\u53EF\u6267\u884C\u6587\u4EF6\u3001zip\u3001tar \u5305)'
             'ip:\u672C\u5730\u6D3B\u8DC3\u7F51\u5361\u53CA\u7F51\u5173\u4FA6\u6D4B'
             'list:\u5217\u51FA\u76EE\u5F55\u4E2D\u7684\u6240\u6709\u6587\u4EF6\u548C\u76EE\u5F55\uFF08\u542B\u9690\u85CF\u9879\uFF09'
             'move:\u79FB\u52A8\u6216\u91CD\u547D\u540D\u6587\u4EF6\u53CA\u76EE\u5F55'
@@ -121,7 +121,7 @@ _xx() {
             'remove:\u5B89\u5168\u5730\u5C06\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u79FB\u81F3\u7CFB\u7EDF\u56DE\u6536\u7AD9\uFF08\u652F\u6301\u901A\u914D\u7B26\u53CA\u591A\u9009\uFF09'
             'search:\u9012\u5F52\u641C\u7D22\u76EE\u5F55\u4E0B\u5305\u542B\u6307\u5B9A\u5173\u952E\u8BCD\u7684\u6587\u4EF6\u6216\u76EE\u5F55'
             'translate:\u7EC8\u7AEF\u7FFB\u8BD1\u5DE5\u5177'
-            'uninstall:\u901A\u7528\u5E94\u7528\u5378\u8F7D\u5668\uFF08\u652F\u6301\u5305\u540D\u3001Flatpak\u3001Snap\u3001\u672C\u5730\u5305\u6216\u7EFF\u8272\u8F6F\u4EF6\uFF09'
+            'uninstall:macOS/Windows \u672C\u5730\u5DE5\u5177\u5378\u8F7D\u5668\uFF08\u79FB\u9664\u5B89\u88C5\u76EE\u5F55\u548C\u7EC8\u7AEF\u547D\u4EE4\u5165\u53E3\uFF09'
             'unzip:\u89E3\u538B ZIP \u538B\u7F29\u5305'
             'upgrade:\u81EA\u52A8\u66F4\u65B0 xx \u547D\u4EE4\u884C\u5DE5\u5177\u81F3\u6700\u65B0\u7248\u672C'
             'zip:\u81EA\u52A8\u8FC7\u6EE4\u5E76\u6253\u5305\u4E3A ZIP'
@@ -547,12 +547,12 @@ function isCommandAvailable(cmd) {
 }
 function runCommand(cmd, args, options = {}) {
   const stdio = options.stdio ?? "pipe";
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve13, reject) => {
     const child = spawn(cmd, args, { stdio });
     if (stdio === "inherit" || stdio === "ignore") {
       child.on("error", reject);
       child.on("close", (code) => {
-        resolve14({
+        resolve13({
           success: code === 0,
           code,
           stdout: Buffer.alloc(0),
@@ -567,7 +567,7 @@ function runCommand(cmd, args, options = {}) {
     child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
     child.on("error", reject);
     child.on("close", (code) => {
-      resolve14({
+      resolve13({
         success: code === 0,
         code,
         stdout: Buffer.concat(stdoutChunks),
@@ -764,268 +764,396 @@ function registerFormatCommand(program2) {
 }
 
 // commands/install.ts
+import fs6 from "fs/promises";
+import pc6 from "picocolors";
+import { resolve as resolve4, join as join5, basename as basename3 } from "path";
+
+// utils/macos-apps.ts
 import fs5 from "fs/promises";
+import { basename as basename2, delimiter, extname, join as join4 } from "path";
 import pc5 from "picocolors";
-import { resolve as resolve4, join as join4, basename as basename2 } from "path";
+
+// utils/archive.ts
+import AdmZip from "adm-zip";
+import * as tar from "tar";
+import { mkdir } from "fs/promises";
+async function compressZip(sourceDir, outputPath) {
+  const zip = new AdmZip();
+  zip.addLocalFolder(sourceDir);
+  zip.writeZip(outputPath);
+}
+async function uncompressZip(src, destDir) {
+  await mkdir(destDir, { recursive: true });
+  const zip = new AdmZip(src);
+  zip.extractAllTo(destDir, true);
+}
+async function uncompressTar(src, destDir) {
+  await mkdir(destDir, { recursive: true });
+  await tar.x({ file: src, cwd: destDir });
+}
+async function uncompressTgz(src, destDir) {
+  await mkdir(destDir, { recursive: true });
+  await tar.x({ file: src, gzip: true, cwd: destDir });
+}
+
+// utils/macos-apps.ts
+var APP_DIR_NAME = ".xx-tools";
+var PATH_MARKER_BEGIN = "# >>> xx-tools path >>>";
+var PATH_MARKER_END = "# <<< xx-tools path <<<";
 function getHomeDir() {
   return process.env["HOME"] || process.env["USERPROFILE"] || process.cwd();
 }
-async function createShortcut(targetPath) {
-  const home = getHomeDir();
-  const applicationsDir = join4(home, ".local/share/applications");
-  let name = "";
-  let execLine = "";
-  let desktopFileName = "";
-  const isFlatpak = !targetPath.includes("/") && !targetPath.includes("\\") && targetPath.split(".").length >= 3;
-  if (isFlatpak) {
-    const segments = targetPath.split(".");
-    name = segments[segments.length - 1];
-    execLine = `flatpak run ${targetPath}`;
-    desktopFileName = `flatpak-${targetPath}.desktop`;
-  } else {
-    const absolutePath = resolve4(process.cwd(), targetPath);
-    try {
-      const stat = await fs5.stat(absolutePath);
-      if (!stat.isFile()) {
-        console.error(pc5.red(`\u274C \u9519\u8BEF: '${targetPath}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u6587\u4EF6\u3002`));
-        return;
-      }
-    } catch {
-      console.error(pc5.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u6587\u4EF6 '${targetPath}'\u3002`));
-      return;
-    }
-    const isAppImage = targetPath.toLowerCase().endsWith(".appimage");
-    name = basename2(absolutePath, isAppImage ? ".AppImage" : "");
-    try {
-      await fs5.chmod(absolutePath, 493);
-    } catch {
-    }
-    execLine = isAppImage ? `"${absolutePath}" --no-sandbox` : `"${absolutePath}"`;
-    desktopFileName = `${name.replace(/\s+/g, "-").toLowerCase()}.desktop`;
-  }
-  const desktopFilePath = join4(applicationsDir, desktopFileName);
-  const desktopContent = `[Desktop Entry]
-Name=${name}
-Exec=${execLine}
-Type=Application
-Terminal=false
-Categories=Utility;
-`;
-  try {
-    await fs5.mkdir(applicationsDir, { recursive: true });
-    await fs5.writeFile(desktopFilePath, desktopContent, "utf-8");
-    console.log(pc5.green(`\u2714 \u5FEB\u6377\u65B9\u5F0F\u5DF2\u521B\u5EFA: ${desktopFilePath}`));
-    console.log(pc5.dim(`\u542F\u52A8\u547D\u4EE4: ${execLine}`));
-  } catch (err) {
-    console.error(
-      pc5.red("\u274C \u521B\u5EFA\u5FEB\u6377\u65B9\u5F0F\u5931\u8D25:"),
-      err instanceof Error ? err.message : err
-    );
-  }
+function getToolsRootDir() {
+  return join4(getHomeDir(), APP_DIR_NAME);
 }
-async function installAppImage(absPath) {
-  const home = getHomeDir();
-  const greenAppDir = join4(home, "GreenApp");
-  const fileName = basename2(absPath);
-  const destPath = join4(greenAppDir, fileName);
-  const isAppImage = fileName.toLowerCase().endsWith(".appimage");
-  const appNameClean = basename2(absPath, isAppImage ? ".AppImage" : "");
-  try {
-    await fs5.mkdir(greenAppDir, { recursive: true });
-    console.log(
-      pc5.cyan(`\u{1F4E6} \u6B63\u5728\u5C06 AppImage \u90E8\u7F72\u81F3\u7EFF\u8272\u8F6F\u4EF6\u76EE\u5F55: ${destPath}...`)
-    );
-    await fs5.copyFile(absPath, destPath);
-    await fs5.chmod(destPath, 493);
-    await createShortcut(destPath);
-    console.log(pc5.green(`\u2728 AppImage \u90E8\u7F72\u5B8C\u6210\uFF01`));
-    console.log(
-      pc5.green(
-        `
-\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u8BE5\u7EFF\u8272\u8F6F\u4EF6\u7684\u5378\u8F7D\u540D\u79F0\u4E3A: ${pc5.bold(appNameClean)}`
-      )
-    );
-    console.log(pc5.cyan(`\u{1F449} \u4EE5\u540E\u60A8\u53EF\u4EE5\u901A\u8FC7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u5F7B\u5E95\u5378\u8F7D\u5B83\uFF1A`));
-    console.log(pc5.bold(pc5.yellow(`  xx delete ${appNameClean}`)));
-  } catch (err) {
+function getAppsDir() {
+  return join4(getToolsRootDir(), "apps");
+}
+function getBinDir() {
+  return join4(getToolsRootDir(), "bin");
+}
+function getManifestPath(appName) {
+  return join4(getAppsDir(), appName, ".xx-manifest.json");
+}
+function ensureSupportedDesktopOS() {
+  if (process.platform !== "darwin" && process.platform !== "win32") {
     console.error(
-      pc5.red("\u274C AppImage \u90E8\u7F72\u5931\u8D25:"),
-      err instanceof Error ? err.message : err
+      pc5.red("\u274C \u5F53\u524D install/uninstall \u4EC5\u652F\u6301 macOS \u548C Windows\u3002")
     );
+    return false;
   }
+  return true;
 }
-async function installDeb(absPath) {
-  console.log(pc5.cyan(`\u{1F4E6} \u6B63\u5728\u901A\u8FC7 dpkg \u672C\u5730\u5B89\u88C5 DEB \u8F6F\u4EF6\u5305: ${absPath}...`));
-  const status = await spawnCommand("sudo", ["dpkg", "-i", absPath]);
-  if (status.success) {
-    console.log(pc5.green("\u2714 DEB \u8F6F\u4EF6\u5305\u90E8\u7F72\u6210\u529F\uFF01"));
-    try {
-      const { success, stdout } = await runCommand("dpkg-deb", [
-        "-f",
-        absPath,
-        "Package"
-      ]);
-      if (success) {
-        const packageName = decodeOutput(stdout).trim();
-        console.log(
-          pc5.green(
-            `
-\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u8BE5\u8F6F\u4EF6\u5305\u7684\u5B98\u65B9\u5378\u8F7D\u540D\u79F0\u4E3A: ${pc5.bold(packageName)}`
-          )
-        );
-        console.log(pc5.cyan(`\u{1F449} \u4EE5\u540E\u60A8\u53EF\u4EE5\u901A\u8FC7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u5F7B\u5E95\u5378\u8F7D\u5B83\uFF1A`));
-        console.log(pc5.bold(pc5.yellow(`  xx delete ${packageName}`)));
-      }
-    } catch {
-    }
+async function ensureToolDirectories() {
+  await fs5.mkdir(getAppsDir(), { recursive: true });
+  await fs5.mkdir(getBinDir(), { recursive: true });
+}
+function getPreferredProfiles() {
+  const home = getHomeDir();
+  const shell = process.env["SHELL"] || "";
+  const profiles = [];
+  if (shell.includes("zsh")) {
+    profiles.push(join4(home, ".zshrc"), join4(home, ".zprofile"));
+  } else if (shell.includes("bash")) {
+    profiles.push(join4(home, ".bashrc"), join4(home, ".bash_profile"));
   } else {
-    console.error(pc5.red(`\u274C \u5B89\u88C5\u5931\u8D25\uFF0C\u8FDB\u7A0B\u9000\u51FA\u7801: ${status.code}`));
+    profiles.push(join4(home, ".zshrc"), join4(home, ".zprofile"));
   }
+  return Array.from(new Set(profiles));
 }
-async function installRpm(absPath) {
-  console.log(pc5.cyan(`\u{1F4E6} \u6B63\u5728\u901A\u8FC7 dnf \u672C\u5730\u5B89\u88C5 RPM \u8F6F\u4EF6\u5305: ${absPath}...`));
-  const status = await spawnCommand("sudo", ["dnf", "install", "-y", absPath]);
-  if (status.success) {
-    console.log(pc5.green("\u2714 RPM \u8F6F\u4EF6\u5305\u90E8\u7F72\u6210\u529F\uFF01"));
+async function ensureBinDirOnPath() {
+  if (process.platform === "win32") {
+    await ensureWindowsBinDirOnPath();
+    return;
+  }
+  const pathBlock = `${PATH_MARKER_BEGIN}
+export PATH="$HOME/${APP_DIR_NAME}/bin:$PATH"
+${PATH_MARKER_END}`;
+  for (const profilePath of getPreferredProfiles()) {
+    let content = "";
     try {
-      const { success, stdout } = await runCommand("rpm", [
-        "-qp",
-        "--queryformat",
-        "%{NAME}",
-        absPath
-      ]);
-      if (success) {
-        const packageName = decodeOutput(stdout).trim();
-        console.log(
-          pc5.green(
-            `
-\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u8BE5\u8F6F\u4EF6\u5305\u7684\u5B98\u65B9\u5378\u8F7D\u540D\u79F0\u4E3A: ${pc5.bold(packageName)}`
-          )
-        );
-        console.log(pc5.cyan(`\u{1F449} \u4EE5\u540E\u60A8\u53EF\u4EE5\u901A\u8FC7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u5F7B\u5E95\u5378\u8F7D\u5B83\uFF1A`));
-        console.log(pc5.bold(pc5.yellow(`  xx delete ${packageName}`)));
-      }
+      content = await fs5.readFile(profilePath, "utf-8");
     } catch {
     }
-  } else {
-    console.error(pc5.red(`\u274C \u5B89\u88C5\u5931\u8D25\uFF0C\u8FDB\u7A0B\u9000\u51FA\u7801: ${status.code}`));
+    if (!content.includes(PATH_MARKER_BEGIN)) {
+      const separator = content.endsWith("\n") || content === "" ? "" : "\n";
+      await fs5.writeFile(
+        profilePath,
+        `${content}${separator}${pathBlock}
+`,
+        "utf-8"
+      );
+      console.log(pc5.green(`\u2714 \u5DF2\u5199\u5165 PATH \u914D\u7F6E: ${profilePath}`));
+    }
+  }
+}
+async function ensureWindowsBinDirOnPath() {
+  const binDir = getBinDir();
+  const currentUserPath = process.env["Path"] || process.env["PATH"] || "";
+  const alreadyInCurrentEnv = currentUserPath.split(delimiter).some((item) => item.trim().toLowerCase() === binDir.toLowerCase());
+  const script = [
+    "$binDir = [System.IO.Path]::GetFullPath($args[0])",
+    "$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')",
+    "if ([string]::IsNullOrWhiteSpace($userPath)) { $userPath = '' }",
+    "$items = $userPath -split ';' | Where-Object { $_ -and $_.Trim() -ne '' }",
+    "$exists = $items | Where-Object { $_.Trim().ToLower() -eq $binDir.ToLower() }",
+    "if (-not $exists) {",
+    '  $newPath = if ($userPath) { "$binDir;$userPath" } else { $binDir }',
+    "  [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')",
+    "  Write-Output 'UPDATED'",
+    "} else {",
+    "  Write-Output 'UNCHANGED'",
+    "}"
+  ].join(" ");
+  const { success, stdout } = await runCommand("powershell", [
+    "-NoProfile",
+    "-Command",
+    script,
+    binDir
+  ]);
+  if (success) {
+    const output = decodeOutput(stdout).trim();
+    if (output.includes("UPDATED")) {
+      console.log(pc5.green(`\u2714 \u5DF2\u5199\u5165\u7528\u6237 PATH: ${binDir}`));
+    } else if (!alreadyInCurrentEnv) {
+      console.log(pc5.dim(`\u2796 \u7528\u6237 PATH \u4E2D\u5DF2\u5B58\u5728: ${binDir}`));
+    }
   }
 }
-async function installTarGz(absPath) {
-  const home = getHomeDir();
-  if (!home) {
-    console.error(pc5.red("\u274C \u9519\u8BEF: \u65E0\u6CD5\u83B7\u53D6\u7528\u6237\u6839\u76EE\u5F55\u3002"));
-    return;
+function getShellReloadCommand() {
+  if (process.platform === "win32") {
+    return "\u91CD\u65B0\u6253\u5F00 PowerShell \u6216 CMD";
   }
-  const greenAppDir = join4(home, "GreenApp");
-  const folderName = basename2(absPath, ".tar.gz").replace(".tar", "");
-  const destDir = join4(greenAppDir, folderName);
-  try {
-    await fs5.mkdir(destDir, { recursive: true });
-    console.log(pc5.cyan(`\u{1F4E6} \u6B63\u5728\u89E3\u538B\u7EFF\u8272\u8F6F\u4EF6\u81F3: ${destDir}...`));
-    const tarStatus = await spawnCommand("tar", [
-      "-xzf",
-      absPath,
-      "-C",
-      destDir
-    ]);
-    if (!tarStatus.success) {
-      console.error(pc5.red("\u274C \u89E3\u538B\u5931\u8D25\u3002"));
-      return;
+  const shell = process.env["SHELL"] || "";
+  if (shell.includes("zsh")) {
+    return "source ~/.zshrc";
+  }
+  if (shell.includes("bash")) {
+    return "source ~/.bashrc";
+  }
+  return "source ~/.zshrc";
+}
+function stripArchiveSuffix(filePath) {
+  const lower = filePath.toLowerCase();
+  const name = basename2(filePath);
+  const suffixes = [".tar.gz", ".tgz", ".tar.xz", ".txz", ".zip", ".tar"];
+  for (const suffix of suffixes) {
+    if (lower.endsWith(suffix)) {
+      return name.slice(0, name.length - suffix.length);
     }
-    console.log(
-      pc5.green("\u2714 \u89E3\u538B\u5B8C\u6210\u3002\u6B63\u5728\u626B\u63CF\u4E3B\u6267\u884C\u6587\u4EF6\u4EE5\u81EA\u52A8\u914D\u7F6E\u5FEB\u6377\u65B9\u5F0F...")
-    );
-    let exePath = "";
-    for (const entry of await fs5.readdir(destDir, { withFileTypes: true })) {
-      if (entry.isFile()) {
-        const fullPath = join4(destDir, entry.name);
-        const stat = await fs5.stat(fullPath);
+  }
+  return basename2(filePath, extname(filePath));
+}
+async function removeDirectoryContents(dirPath) {
+  await fs5.rm(dirPath, { recursive: true, force: true });
+  await fs5.mkdir(dirPath, { recursive: true });
+}
+async function findExecutablesRecursively(rootDir) {
+  const matches = [];
+  async function walk(currentDir) {
+    for (const entry of await fs5.readdir(currentDir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = join4(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (["node_modules", "lib", "libs", "include", "share", "man"].includes(
+          entry.name
+        )) {
+          continue;
+        }
+        await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const stat = await fs5.stat(fullPath);
+      if (process.platform === "win32") {
+        if (!/\.(exe|cmd|bat|ps1)$/i.test(entry.name)) {
+          continue;
+        }
+      } else {
         const isExecutable = stat.mode ? (stat.mode & 73) !== 0 : false;
-        if (isExecutable && !entry.name.endsWith(".sh") && !entry.name.endsWith(".so")) {
-          exePath = fullPath;
-          break;
+        if (!isExecutable) continue;
+        if (/\.(dylib|so|a|o|txt|md|json|yaml|yml|ts|js|c|h|sh)$/i.test(
+          entry.name
+        )) {
+          continue;
         }
       }
+      matches.push(fullPath);
     }
-    if (exePath) {
-      console.log(pc5.cyan(`\u{1F50D} \u53D1\u73B0\u53EF\u6267\u884C\u4E8C\u8FDB\u5236\u6587\u4EF6: ${exePath}`));
-      await createShortcut(exePath);
-      console.log(
-        pc5.green(
-          `
-\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u8BE5\u7EFF\u8272\u5E94\u7528\u7684\u5378\u8F7D\u540D\u79F0\u4E3A: ${pc5.bold(folderName)}`
-        )
+  }
+  await walk(rootDir);
+  return matches;
+}
+async function createLinks(appName, executablePaths) {
+  const binDir = getBinDir();
+  const linkNames = [];
+  for (const executablePath of executablePaths) {
+    const executableBaseName = basename2(executablePath);
+    if (process.platform === "win32") {
+      const commandName = basename2(
+        executableBaseName,
+        extname(executableBaseName)
       );
-      console.log(pc5.cyan(`\u{1F449} \u4EE5\u540E\u60A8\u53EF\u4EE5\u901A\u8FC7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u5F7B\u5E95\u5378\u8F7D\u5B83\uFF1A`));
-      console.log(pc5.bold(pc5.yellow(`  xx delete ${folderName}`)));
-    } else {
-      console.log(
-        pc5.yellow(
-          "\u26A0\uFE0F \u672A\u80FD\u5728\u89E3\u538B\u76EE\u5F55\u4E0B\u5B9A\u4F4D\u5230\u660E\u786E\u7684\u53EF\u6267\u884C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u8BF7\u540E\u7EED\u624B\u52A8\u521B\u5EFA\u3002"
-        )
+      const cmdPath = join4(binDir, `${commandName}.cmd`);
+      const ps1Path = join4(binDir, `${commandName}.ps1`);
+      const quotedExecutable = executablePath.replace(/"/g, '""');
+      await fs5.rm(cmdPath, { force: true });
+      await fs5.rm(ps1Path, { force: true });
+      await fs5.writeFile(
+        cmdPath,
+        `@echo off\r
+"${quotedExecutable}" %*\r
+`,
+        "utf-8"
       );
+      await fs5.writeFile(ps1Path, `& "${quotedExecutable}" @args
+`, "utf-8");
+      linkNames.push(commandName);
+    } else {
+      const linkName = executableBaseName;
+      const linkPath = join4(binDir, linkName);
+      await fs5.rm(linkPath, { force: true });
+      await fs5.symlink(executablePath, linkPath);
+      linkNames.push(linkName);
     }
-  } catch (err) {
+  }
+  if (linkNames.length > 0) {
+    console.log(
+      pc5.green(
+        `\u2714 \u5DF2\u4E3A ${pc5.bold(appName)} \u521B\u5EFA\u7EC8\u7AEF\u547D\u4EE4: ${linkNames.join(", ")}`
+      )
+    );
+  }
+  return linkNames;
+}
+async function writeManifest(manifest) {
+  await fs5.writeFile(
+    getManifestPath(manifest.appName),
+    JSON.stringify(manifest, null, 2),
+    "utf-8"
+  );
+}
+async function readManifest(appName) {
+  try {
+    const content = await fs5.readFile(getManifestPath(appName), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function removeInstalledApp(appName) {
+  const manifest = await readManifest(appName);
+  if (!manifest) return false;
+  for (const linkName of manifest.links) {
+    if (process.platform === "win32") {
+      await fs5.rm(join4(getBinDir(), `${linkName}.cmd`), { force: true });
+      await fs5.rm(join4(getBinDir(), `${linkName}.ps1`), { force: true });
+    } else {
+      await fs5.rm(join4(getBinDir(), linkName), { force: true });
+    }
+    console.log(pc5.green(`\u2714 \u5DF2\u79FB\u9664\u7EC8\u7AEF\u547D\u4EE4: ${linkName}`));
+  }
+  await fs5.rm(manifest.installDir, { recursive: true, force: true });
+  console.log(pc5.green(`\u2714 \u5DF2\u79FB\u9664\u5B89\u88C5\u76EE\u5F55: ${manifest.installDir}`));
+  return true;
+}
+async function listInstalledApps() {
+  try {
+    const entries = await fs5.readdir(getAppsDir(), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function extractArchiveToDir(archivePath, destDir) {
+  const lower = archivePath.toLowerCase();
+  if (lower.endsWith(".zip")) {
+    await uncompressZip(archivePath, destDir);
+    return true;
+  }
+  let args;
+  if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz")) {
+    args = ["-xzf", archivePath, "-C", destDir];
+  } else if (lower.endsWith(".tar.xz") || lower.endsWith(".txz")) {
+    args = ["-xJf", archivePath, "-C", destDir];
+  } else if (lower.endsWith(".tar")) {
+    args = ["-xf", archivePath, "-C", destDir];
+  } else {
+    return false;
+  }
+  const result = await spawnCommand("tar", args);
+  return result.success;
+}
+
+// commands/install.ts
+function printReloadHint() {
+  const reloadCommand = getShellReloadCommand();
+  console.log(
+    pc6.yellow(`\u{1F4A1} \u5982\u679C\u5F53\u524D\u7EC8\u7AEF\u8FD8\u4E0D\u80FD\u76F4\u63A5\u8FD0\u884C\u65B0\u547D\u4EE4\uFF0C\u8BF7\u6267\u884C: ${reloadCommand}`)
+  );
+}
+async function installBinary(absPath) {
+  const appName = basename3(absPath);
+  const installDir = join5(getAppsDir(), appName);
+  const targetDir = join5(installDir, "bin");
+  const targetPath = join5(targetDir, appName);
+  await fs6.mkdir(targetDir, { recursive: true });
+  await fs6.copyFile(absPath, targetPath);
+  await fs6.chmod(targetPath, 493);
+  const links = await createLinks(appName, [targetPath]);
+  await writeManifest({
+    appName,
+    installDir,
+    links,
+    type: "binary"
+  });
+  console.log(pc6.green(`\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u53EF\u76F4\u63A5\u5728\u7EC8\u7AEF\u4E2D\u8FD0\u884C: ${pc6.bold(appName)}`));
+  console.log(pc6.cyan(`\u{1F449} \u5378\u8F7D\u547D\u4EE4: ${pc6.bold(`xx uninstall ${appName}`)}`));
+  printReloadHint();
+}
+async function installArchive(absPath) {
+  const appName = stripArchiveSuffix(absPath);
+  const installDir = join5(getAppsDir(), appName);
+  await removeDirectoryContents(installDir);
+  console.log(pc6.cyan(`\u{1F4E6} \u6B63\u5728\u89E3\u538B\u8F6F\u4EF6\u5305\u81F3: ${installDir}...`));
+  const extracted = await extractArchiveToDir(absPath, installDir);
+  if (!extracted) {
     console.error(
-      pc5.red("\u274C \u7EFF\u8272\u8F6F\u4EF6\u5B89\u88C5\u5931\u8D25:"),
-      err instanceof Error ? err.message : err
+      pc6.red("\u274C \u5F53\u524D\u4EC5\u652F\u6301 .tar.gz\u3001.tgz\u3001.tar.xz\u3001.txz\u3001.tar \u683C\u5F0F\u3002")
     );
+    return;
+  }
+  const executables = await findExecutablesRecursively(installDir);
+  if (executables.length === 0) {
+    console.error(pc6.red("\u274C \u89E3\u538B\u5B8C\u6210\uFF0C\u4F46\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6\u3002"));
+    return;
   }
+  const links = await createLinks(appName, executables);
+  await writeManifest({
+    appName,
+    installDir,
+    links,
+    type: "archive"
+  });
+  console.log(
+    pc6.green(`\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u53EF\u76F4\u63A5\u5728\u7EC8\u7AEF\u4E2D\u8FD0\u884C: ${pc6.bold(links.join(", "))}`)
+  );
+  console.log(pc6.cyan(`\u{1F449} \u5378\u8F7D\u547D\u4EE4: ${pc6.bold(`xx uninstall ${appName}`)}`));
+  printReloadHint();
 }
 function registerInstallCommand(program2) {
   program2.command("install [path]").description(
-    "\u901A\u7528\u5E94\u7528\u90E8\u7F72\u5B89\u88C5\uFF08\u81EA\u52A8\u5206\u53D1\u9002\u914D AppImage\u3001Flatpak ID\u3001tar.gz\u3001deb \u53CA rpm \u683C\u5F0F\u5305\uFF09"
+    "macOS/Windows \u672C\u5730\u5DE5\u5177\u5B89\u88C5\u5668\uFF08\u652F\u6301\u53EF\u6267\u884C\u6587\u4EF6\u3001.zip\u3001.tar.gz\u3001.tgz\u3001.tar.xz\u3001.txz\u3001.tar\uFF09"
   ).action(async (target) => {
+    if (!ensureSupportedDesktopOS()) return;
     if (!target) {
-      console.error(pc5.red("\u274C \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u5B89\u88C5\u5305\u6587\u4EF6\u8DEF\u5F84\u6216 Flatpak ID\u3002"));
-      return;
-    }
-    const isFlatpak = !target.includes("/") && !target.includes("\\") && target.split(".").length >= 3;
-    if (isFlatpak) {
-      await createShortcut(target);
-      console.log(
-        pc5.green(
-          `
-\u2728 \u5B89\u88C5\u6210\u529F\uFF01\u8BE5 Flatpak \u5FEB\u6377\u56FE\u6807\u7684\u5378\u8F7D\u540D\u79F0\u4E3A: ${pc5.bold(target)}`
-        )
-      );
-      console.log(pc5.cyan(`\u{1F449} \u4EE5\u540E\u60A8\u53EF\u4EE5\u901A\u8FC7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u5220\u9664\u8BE5\u5FEB\u6377\u56FE\u6807\uFF1A`));
-      console.log(pc5.bold(pc5.yellow(`  xx delete ${target}`)));
+      console.error(pc6.red("\u274C \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u672C\u5730\u6587\u4EF6\u8DEF\u5F84\u3002"));
       return;
     }
     const absPath = resolve4(process.cwd(), target);
     try {
-      await fs5.stat(absPath);
+      const stat = await fs6.stat(absPath);
+      if (!stat.isFile()) {
+        console.error(pc6.red(`\u274C \u9519\u8BEF: '${target}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u6587\u4EF6\u3002`));
+        return;
+      }
     } catch {
-      console.error(pc5.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u6307\u5B9A\u6587\u4EF6\u6216\u5305\u8DEF\u5F84 '${target}'\u3002`));
+      console.error(pc6.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u6307\u5B9A\u6587\u4EF6\u6216\u5305\u8DEF\u5F84 '${target}'\u3002`));
       return;
     }
+    await ensureToolDirectories();
+    await ensureBinDirOnPath();
     const lowerPath = target.toLowerCase();
-    if (lowerPath.endsWith(".appimage")) {
-      await installAppImage(absPath);
-    } else if (lowerPath.endsWith(".deb")) {
-      await installDeb(absPath);
-    } else if (lowerPath.endsWith(".rpm")) {
-      await installRpm(absPath);
-    } else if (lowerPath.endsWith(".tar.gz") || lowerPath.endsWith(".tgz")) {
-      await installTarGz(absPath);
+    if (lowerPath.endsWith(".zip") || lowerPath.endsWith(".tar.gz") || lowerPath.endsWith(".tgz") || lowerPath.endsWith(".tar.xz") || lowerPath.endsWith(".txz") || lowerPath.endsWith(".tar")) {
+      await installArchive(absPath);
     } else {
-      console.log(
-        pc5.cyan(`\u{1F4E6} \u68C0\u6D4B\u5230\u901A\u7528\u672C\u5730\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u6B63\u5728\u76F4\u63A5\u4E3A\u5176\u914D\u7F6E\u684C\u9762\u56FE\u6807...`)
-      );
-      await createShortcut(absPath);
-      const execName = basename2(absPath);
-      console.log(
-        pc5.green(`
-\u2728 \u5FEB\u6377\u65B9\u5F0F\u521B\u5EFA\u6210\u529F\uFF01\u540D\u79F0\u4E3A: ${pc5.bold(execName)}`)
-      );
+      await installBinary(absPath);
     }
   });
 }
 
 // commands/ip.ts
-import pc6 from "picocolors";
+import pc7 from "picocolors";
 import os from "os";
 function getInterfaceType(name) {
   const lowerName = name.toLowerCase();
@@ -1199,7 +1327,7 @@ async function getDefaultRouteInfo() {
 }
 function registerIpCommand(program2) {
   program2.command("ip").description("\u672C\u5730\u6D3B\u8DC3\u7F51\u5361\u3001\u672C\u673AIP\u53CA\u7F51\u5173\u4FA6\u6D4B\u5DE5\u5177").action(async () => {
-    console.log(pc6.dim("\u6B63\u5728\u5206\u6790\u7F51\u7EDC\u914D\u7F6E\uFF0C\u8BF7\u7A0D\u5019...\n"));
+    console.log(pc7.dim("\u6B63\u5728\u5206\u6790\u7F51\u7EDC\u914D\u7F6E\uFF0C\u8BF7\u7A0D\u5019...\n"));
     try {
       let defaultRoute = { gateway: "", interfaceName: "" };
       let routeError = "";
@@ -1210,7 +1338,7 @@ function registerIpCommand(program2) {
       }
       const cards = getActiveNetworkCards();
       if (cards.length === 0) {
-        console.log(pc6.red("\u274C \u672A\u68C0\u6D4B\u5230\u4EFB\u4F55\u6D3B\u8DC3\u7684\u975E\u672C\u5730\u56DE\u73AF\u7F51\u5361\u3002"));
+        console.log(pc7.red("\u274C \u672A\u68C0\u6D4B\u5230\u4EFB\u4F55\u6D3B\u8DC3\u7684\u975E\u672C\u5730\u56DE\u73AF\u7F51\u5361\u3002"));
         return;
       }
       cards.sort((a, b) => {
@@ -1247,76 +1375,76 @@ function registerIpCommand(program2) {
             ipv4.netmask
           );
         }
-        let cardGateway = pc6.dim("(\u975E\u9ED8\u8BA4\u8DEF\u7531\u51FA\u53E3\u7F51\u5361)");
+        let cardGateway = pc7.dim("(\u975E\u9ED8\u8BA4\u8DEF\u7531\u51FA\u53E3\u7F51\u5361)");
         if (isDefaultRouteCard) {
           if (defaultRoute.gateway && defaultRoute.gateway !== "0.0.0.0") {
-            cardGateway = pc6.yellow(defaultRoute.gateway);
+            cardGateway = pc7.yellow(defaultRoute.gateway);
           } else {
-            cardGateway = pc6.yellow("\u76F4\u63A5\u70B9\u5BF9\u70B9\u96A7\u9053\u8FDE\u63A5 (Point-to-Point)");
+            cardGateway = pc7.yellow("\u76F4\u63A5\u70B9\u5BF9\u70B9\u96A7\u9053\u8FDE\u63A5 (Point-to-Point)");
           }
         } else if (routeError) {
-          cardGateway = pc6.dim(`\u68C0\u6D4B\u5931\u8D25 (\u539F\u56E0: ${routeError})`);
+          cardGateway = pc7.dim(`\u68C0\u6D4B\u5931\u8D25 (\u539F\u56E0: ${routeError})`);
         }
         console.log(
-          pc6.cyan(
+          pc7.cyan(
             `================ \u6D3B\u8DC3\u7F51\u5361\u53CA\u7F51\u5173\u4FE1\u606F [${card.type}] ================`
           )
         );
         console.log(
-          `${pc6.green("\u7F51\u5361\u540D\u79F0 (Name):")}   ${pc6.bold(card.name)}`
+          `${pc7.green("\u7F51\u5361\u540D\u79F0 (Name):")}   ${pc7.bold(card.name)}`
         );
         console.log(
-          `${pc6.green("\u672C\u673A IP \u5730\u5740 (IP):")}  ${pc6.bold(primaryAddr.address)}`
+          `${pc7.green("\u672C\u673A IP \u5730\u5740 (IP):")}  ${pc7.bold(primaryAddr.address)}`
         );
         console.log(
-          `${pc6.green("\u5B50\u7F51\u63A9\u7801 (Mask):")}   ${primaryAddr.netmask}`
+          `${pc7.green("\u5B50\u7F51\u63A9\u7801 (Mask):")}   ${primaryAddr.netmask}`
         );
-        console.log(`${pc6.green("\u9ED8\u8BA4\u7F51\u5173 (Gateway):")} ${cardGateway}`);
-        console.log(`${pc6.green("MAC \u5730\u5740 (MAC):")}    ${card.mac}`);
+        console.log(`${pc7.green("\u9ED8\u8BA4\u7F51\u5173 (Gateway):")} ${cardGateway}`);
+        console.log(`${pc7.green("MAC \u5730\u5740 (MAC):")}    ${card.mac}`);
         console.log(
-          `${pc6.green("IP \u534F\u8BAE\u7248\u672C:")}       ${primaryAddr.family === "IPv4" || primaryAddr.family === "4" ? "IPv4" : "IPv6"}`
+          `${pc7.green("IP \u534F\u8BAE\u7248\u672C:")}       ${primaryAddr.family === "IPv4" || primaryAddr.family === "4" ? "IPv4" : "IPv6"}`
         );
         if (ipv4 && ipv6) {
           console.log(
-            `${pc6.green("\u672C\u5730 IPv6 \u5730\u5740:")}     ${pc6.dim(ipv6.address)}`
+            `${pc7.green("\u672C\u5730 IPv6 \u5730\u5740:")}     ${pc7.dim(ipv6.address)}`
           );
         }
         console.log(
-          pc6.cyan("====================================================")
+          pc7.cyan("====================================================")
         );
         console.log("");
       }
     } catch (error) {
-      console.error(pc6.red("\u274C \u68C0\u6D4B\u5931\u8D25\u3002"));
+      console.error(pc7.red("\u274C \u68C0\u6D4B\u5931\u8D25\u3002"));
       if (error instanceof Error) {
-        console.error(pc6.red("\u9519\u8BEF\u8BE6\u60C5:"), error.message);
+        console.error(pc7.red("\u9519\u8BEF\u8BE6\u60C5:"), error.message);
       }
     }
   });
 }
 
 // commands/list.ts
-import fs6 from "fs/promises";
-import pc7 from "picocolors";
+import fs7 from "fs/promises";
+import pc8 from "picocolors";
 import { resolve as resolve5 } from "path";
 function registerLsCommand(program2) {
   program2.command("list [path]").description("\u5217\u51FA\u76EE\u5F55\u4E2D\u7684\u6240\u6709\u6587\u4EF6\u548C\u76EE\u5F55\uFF08\u542B\u9690\u85CF\u9879\uFF09").action(async (targetPath) => {
     const inputPath = targetPath || ".";
     const absolutePath = resolve5(process.cwd(), inputPath);
     try {
-      const stat = await fs6.stat(absolutePath);
+      const stat = await fs7.stat(absolutePath);
       if (!stat.isDirectory()) {
-        console.error(pc7.red(`\u274C \u9519\u8BEF: '${inputPath}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
+        console.error(pc8.red(`\u274C \u9519\u8BEF: '${inputPath}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
         return;
       }
       const entries = [];
-      for (const entry of await fs6.readdir(absolutePath, {
+      for (const entry of await fs7.readdir(absolutePath, {
         withFileTypes: true
       })) {
         entries.push(entry);
       }
       if (entries.length === 0) {
-        console.log(pc7.dim("\uFF08\u7A7A\u76EE\u5F55\uFF09"));
+        console.log(pc8.dim("\uFF08\u7A7A\u76EE\u5F55\uFF09"));
         return;
       }
       entries.sort((a, b) => {
@@ -1328,13 +1456,13 @@ function registerLsCommand(program2) {
         const isHidden = entry.name.startsWith(".");
         if (entry.isDirectory()) {
           if (isHidden) {
-            console.log(pc7.dim(`\u{1F4C1} ${pc7.blue(entry.name)}/`));
+            console.log(pc8.dim(`\u{1F4C1} ${pc8.blue(entry.name)}/`));
           } else {
-            console.log(`\u{1F4C1} ${pc7.blue(pc7.bold(entry.name))}/`);
+            console.log(`\u{1F4C1} ${pc8.blue(pc8.bold(entry.name))}/`);
           }
         } else {
           if (isHidden) {
-            console.log(pc7.dim(`\u{1F4C4} ${entry.name}`));
+            console.log(pc8.dim(`\u{1F4C4} ${entry.name}`));
           } else {
             console.log(`\u{1F4C4} ${entry.name}`);
           }
@@ -1342,7 +1470,7 @@ function registerLsCommand(program2) {
       }
     } catch (err) {
       console.error(
-        pc7.red(`\u274C \u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55\u5185\u5BB9:`),
+        pc8.red(`\u274C \u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55\u5185\u5BB9:`),
         err instanceof Error ? err.message : err
       );
     }
@@ -1350,55 +1478,55 @@ function registerLsCommand(program2) {
 }
 
 // commands/move.ts
-import fs7 from "fs/promises";
-import pc8 from "picocolors";
-import { dirname as dirname4, resolve as resolve6, join as join5, basename as basename3 } from "path";
+import fs8 from "fs/promises";
+import pc9 from "picocolors";
+import { dirname as dirname3, resolve as resolve6, join as join6, basename as basename4 } from "path";
 async function copyRecursive2(src, dest) {
-  const fileInfo = await fs7.stat(src);
+  const fileInfo = await fs8.stat(src);
   if (fileInfo.isDirectory()) {
-    await fs7.mkdir(dest, { recursive: true });
-    for (const entry of await fs7.readdir(src, { withFileTypes: true })) {
-      await copyRecursive2(join5(src, entry.name), join5(dest, entry.name));
+    await fs8.mkdir(dest, { recursive: true });
+    for (const entry of await fs8.readdir(src, { withFileTypes: true })) {
+      await copyRecursive2(join6(src, entry.name), join6(dest, entry.name));
     }
   } else if (fileInfo.isFile()) {
-    await fs7.mkdir(dirname4(dest), { recursive: true });
-    await fs7.copyFile(src, dest);
+    await fs8.mkdir(dirname3(dest), { recursive: true });
+    await fs8.copyFile(src, dest);
   }
 }
 function registerMoveCommand(program2) {
   program2.command("move <source> <target>").description("\u79FB\u52A8\u6216\u91CD\u547D\u540D\u6587\u4EF6\u53CA\u76EE\u5F55").action(async (source, target) => {
     if (!source || !target) {
-      console.error(pc8.red("\u274C \u8BF7\u63D0\u4F9B\u6E90\u8DEF\u5F84\u548C\u76EE\u6807\u8DEF\u5F84"));
+      console.error(pc9.red("\u274C \u8BF7\u63D0\u4F9B\u6E90\u8DEF\u5F84\u548C\u76EE\u6807\u8DEF\u5F84"));
       return;
     }
     const absSource = resolve6(process.cwd(), source);
     const absTarget = resolve6(process.cwd(), target);
     try {
-      await fs7.stat(absSource);
+      await fs8.stat(absSource);
       let finalTarget = absTarget;
       try {
-        const targetStat = await fs7.stat(absTarget);
+        const targetStat = await fs8.stat(absTarget);
         if (targetStat.isDirectory()) {
-          finalTarget = join5(absTarget, basename3(absSource));
+          finalTarget = join6(absTarget, basename4(absSource));
         }
       } catch {
       }
-      const targetParentDir = dirname4(finalTarget);
-      await fs7.mkdir(targetParentDir, { recursive: true });
-      console.log(pc8.cyan(`\u{1F4E6} \u6B63\u5728\u79FB\u52A8: ${source} \u27A1\uFE0F ${target}...`));
+      const targetParentDir = dirname3(finalTarget);
+      await fs8.mkdir(targetParentDir, { recursive: true });
+      console.log(pc9.cyan(`\u{1F4E6} \u6B63\u5728\u79FB\u52A8: ${source} \u27A1\uFE0F ${target}...`));
       try {
-        await fs7.rename(absSource, finalTarget);
+        await fs8.rename(absSource, finalTarget);
       } catch {
         await copyRecursive2(absSource, finalTarget);
-        await fs7.rm(absSource, { recursive: true });
+        await fs8.rm(absSource, { recursive: true });
       }
-      console.log(pc8.green(`\u2728 \u79FB\u52A8\u6210\u529F: ${source} \u27A1\uFE0F ${target}`));
+      console.log(pc9.green(`\u2728 \u79FB\u52A8\u6210\u529F: ${source} \u27A1\uFE0F ${target}`));
     } catch (err) {
       if (isNotFoundError(err)) {
-        console.error(pc8.red(`\u274C \u9519\u8BEF: \u6E90\u8DEF\u5F84\u4E0D\u5B58\u5728: ${absSource}`));
+        console.error(pc9.red(`\u274C \u9519\u8BEF: \u6E90\u8DEF\u5F84\u4E0D\u5B58\u5728: ${absSource}`));
       } else {
         console.error(
-          pc8.red("\u274C \u79FB\u52A8\u5931\u8D25:"),
+          pc9.red("\u274C \u79FB\u52A8\u5931\u8D25:"),
           err instanceof Error ? err.message : err
         );
       }
@@ -1407,21 +1535,21 @@ function registerMoveCommand(program2) {
 }
 
 // commands/open.ts
-import fs8 from "fs/promises";
-import pc9 from "picocolors";
+import fs9 from "fs/promises";
+import pc10 from "picocolors";
 import { resolve as resolve7 } from "path";
 function registerOpenCommand(program2) {
   program2.command("open [path]").description("\u5728\u7CFB\u7EDF\u6587\u4EF6\u7BA1\u7406\u5668\u4E2D\u6253\u5F00\u6307\u5B9A\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09").action(async (targetPath) => {
     const inputPath = targetPath || ".";
     const absolutePath = resolve7(process.cwd(), inputPath);
     try {
-      const stat = await fs8.stat(absolutePath);
+      const stat = await fs9.stat(absolutePath);
       if (!stat.isDirectory()) {
-        console.error(pc9.red(`\u274C \u9519\u8BEF: '${inputPath}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
+        console.error(pc10.red(`\u274C \u9519\u8BEF: '${inputPath}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
         return;
       }
     } catch {
-      console.error(pc9.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u76EE\u5F55 '${inputPath}'\u3002`));
+      console.error(pc10.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u76EE\u5F55 '${inputPath}'\u3002`));
       return;
     }
     const os3 = process.platform;
@@ -1437,16 +1565,16 @@ function registerOpenCommand(program2) {
       cmd = "xdg-open";
       args = [absolutePath];
     } else {
-      console.error(pc9.red("\u274C \u6682\u4E0D\u652F\u6301\u5728\u5F53\u524D\u7CFB\u7EDF\u4E0B\u8C03\u8D77\u6587\u4EF6\u7BA1\u7406\u5668\u3002"));
+      console.error(pc10.red("\u274C \u6682\u4E0D\u652F\u6301\u5728\u5F53\u524D\u7CFB\u7EDF\u4E0B\u8C03\u8D77\u6587\u4EF6\u7BA1\u7406\u5668\u3002"));
       return;
     }
     try {
-      console.log(pc9.cyan(`\u{1F4C2} \u6B63\u5728\u6253\u5F00\u6587\u4EF6\u5939: ${absolutePath}...`));
+      console.log(pc10.cyan(`\u{1F4C2} \u6B63\u5728\u6253\u5F00\u6587\u4EF6\u5939: ${absolutePath}...`));
       await spawnCommand(cmd, args);
-      console.log(pc9.green("\u2728 \u6210\u529F\u8C03\u8D77\u6587\u4EF6\u7BA1\u7406\u5668\uFF01"));
+      console.log(pc10.green("\u2728 \u6210\u529F\u8C03\u8D77\u6587\u4EF6\u7BA1\u7406\u5668\uFF01"));
     } catch (err) {
       console.error(
-        pc9.red("\u274C \u65E0\u6CD5\u6253\u5F00\u7BA1\u7406\u5668:"),
+        pc10.red("\u274C \u65E0\u6CD5\u6253\u5F00\u7BA1\u7406\u5668:"),
         err instanceof Error ? err.message : err
       );
     }
@@ -1454,19 +1582,19 @@ function registerOpenCommand(program2) {
 }
 
 // commands/park.ts
-import fs9, { open } from "fs/promises";
+import fs10, { open } from "fs/promises";
 import process2 from "process";
-import pc10 from "picocolors";
-import { join as join6, isAbsolute, resolve as resolve8, dirname as dirname5 } from "path";
+import pc11 from "picocolors";
+import { join as join7, isAbsolute, resolve as resolve8, dirname as dirname4 } from "path";
 var CONFIG_FILE_NAME = ".park_config.json";
 function getConfigFile() {
   const home = process2.env["HOME"] || process2.env["USERPROFILE"] || process2.cwd();
-  return join6(home, CONFIG_FILE_NAME);
+  return join7(home, CONFIG_FILE_NAME);
 }
 async function readConfig() {
   try {
     const path = getConfigFile();
-    const content = await fs9.readFile(path, "utf-8");
+    const content = await fs10.readFile(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -1475,9 +1603,9 @@ async function readConfig() {
 async function writeConfig(config) {
   try {
     const path = getConfigFile();
-    await fs9.writeFile(path, JSON.stringify(config, null, 2));
+    await fs10.writeFile(path, JSON.stringify(config, null, 2));
   } catch (err) {
-    console.error(pc10.red("\u274C \u5199\u5165\u5168\u5C40\u914D\u7F6E\u6587\u4EF6\u5931\u8D25:"), err);
+    console.error(pc11.red("\u274C \u5199\u5165\u5168\u5C40\u914D\u7F6E\u6587\u4EF6\u5931\u8D25:"), err);
   }
 }
 async function downloadImage(imageName, outputFilename, targetDir) {
@@ -1489,8 +1617,8 @@ async function downloadImage(imageName, outputFilename, targetDir) {
     cleanName = decodeURIComponent(cleanName).substring(prefix.length);
   }
   const fullImageName = prefix + cleanName;
-  console.log(pc10.cyan(`\u{1F4E6} \u76EE\u6807\u955C\u50CF: ${pc10.bold(fullImageName)}`));
-  console.log(pc10.dim("\u6B63\u5728\u5411\u6253\u5305\u670D\u52A1\u5668\u63D0\u4EA4\u4EFB\u52A1\uFF0C\u8BF7\u7A0D\u5019...\n"));
+  console.log(pc11.cyan(`\u{1F4E6} \u76EE\u6807\u955C\u50CF: ${pc11.bold(fullImageName)}`));
+  console.log(pc11.dim("\u6B63\u5728\u5411\u6253\u5305\u670D\u52A1\u5668\u63D0\u4EA4\u4EFB\u52A1\uFF0C\u8BF7\u7A0D\u5019...\n"));
   try {
     const response = await fetch("https://city189.cn:1091/", {
       method: "POST",
@@ -1527,15 +1655,15 @@ async function downloadImage(imageName, outputFilename, targetDir) {
         matchedFilename = match[0];
         downloadUrl = `https://city189.cn:1091/download/${matchedFilename}`;
       } else {
-        console.error(pc10.red("\u274C \u672A\u80FD\u5728\u670D\u52A1\u5668\u54CD\u5E94\u4E2D\u5339\u914D\u5230\u6253\u5305\u6587\u4EF6\u540D\u3002"));
-        console.log(pc10.yellow("\u670D\u52A1\u5668\u539F\u59CB\u54CD\u5E94\u5982\u4E0B\uFF1A"));
+        console.error(pc11.red("\u274C \u672A\u80FD\u5728\u670D\u52A1\u5668\u54CD\u5E94\u4E2D\u5339\u914D\u5230\u6253\u5305\u6587\u4EF6\u540D\u3002"));
+        console.log(pc11.yellow("\u670D\u52A1\u5668\u539F\u59CB\u54CD\u5E94\u5982\u4E0B\uFF1A"));
         console.log(text);
         throw new Error("\u65E0\u6CD5\u63D0\u53D6\u6253\u5305\u540E\u7684\u6587\u4EF6\u540D");
       }
     }
-    console.log(pc10.green(`\u2705 \u6253\u5305\u4EFB\u52A1\u63D0\u4EA4\u6210\u529F!`));
-    console.log(pc10.green(`\u{1F517} \u4E0B\u8F7D\u94FE\u63A5: ${pc10.underline(downloadUrl)}`));
-    console.log(pc10.cyan(`
+    console.log(pc11.green(`\u2705 \u6253\u5305\u4EFB\u52A1\u63D0\u4EA4\u6210\u529F!`));
+    console.log(pc11.green(`\u{1F517} \u4E0B\u8F7D\u94FE\u63A5: ${pc11.underline(downloadUrl)}`));
+    console.log(pc11.cyan(`
 \u{1F4E5} \u5F00\u59CB\u4E0B\u8F7D: ${matchedFilename}...`));
     const downloadRes = await fetch(downloadUrl, {
       headers: {
@@ -1560,10 +1688,10 @@ async function downloadImage(imageName, outputFilename, targetDir) {
       downloadDir = config.defaultDownloadDir ? config.defaultDownloadDir : process2.cwd();
     }
     const baseFilename = outputFilename || matchedFilename || "bundle.tar";
-    const finalPath = isAbsolute(baseFilename) ? baseFilename : join6(downloadDir, baseFilename);
-    const targetDirToCreate = dirname5(finalPath);
+    const finalPath = isAbsolute(baseFilename) ? baseFilename : join7(downloadDir, baseFilename);
+    const targetDirToCreate = dirname4(finalPath);
     try {
-      await fs9.mkdir(targetDirToCreate, { recursive: true });
+      await fs10.mkdir(targetDirToCreate, { recursive: true });
     } catch {
     }
     const file = await open(finalPath, "w");
@@ -1590,11 +1718,11 @@ async function downloadImage(imageName, outputFilename, targetDir) {
       }
     }
     await file.close();
-    console.log("\n" + pc10.green(`\u2728 \u4E0B\u8F7D\u5E76\u4FDD\u5B58\u6210\u529F! \u6587\u4EF6\u8DEF\u5F84: ${finalPath}`));
+    console.log("\n" + pc11.green(`\u2728 \u4E0B\u8F7D\u5E76\u4FDD\u5B58\u6210\u529F! \u6587\u4EF6\u8DEF\u5F84: ${finalPath}`));
   } catch (error) {
-    console.error(pc10.red("\n\u274C \u6267\u884C\u5931\u8D25\u3002"));
+    console.error(pc11.red("\n\u274C \u6267\u884C\u5931\u8D25\u3002"));
     if (error instanceof Error) {
-      console.error(pc10.red("\u9519\u8BEF\u8BE6\u60C5:"), error.message);
+      console.error(pc11.red("\u9519\u8BEF\u8BE6\u60C5:"), error.message);
     }
   }
 }
@@ -1607,11 +1735,11 @@ function registerParkCommand(program2) {
       if (options.global) {
         const absPath = resolve8(process2.cwd(), options.global);
         await writeConfig({ defaultDownloadDir: absPath });
-        console.log(pc10.green(`\u2728 \u5DF2\u6210\u529F\u8BBE\u7F6E\u5168\u5C40\u9ED8\u8BA4\u4E0B\u8F7D\u76EE\u5F55\u4E3A: ${absPath}`));
+        console.log(pc11.green(`\u2728 \u5DF2\u6210\u529F\u8BBE\u7F6E\u5168\u5C40\u9ED8\u8BA4\u4E0B\u8F7D\u76EE\u5F55\u4E3A: ${absPath}`));
         return;
       }
       if (!image) {
-        console.error(pc10.red("\u274C \u9519\u8BEF: \u672A\u6307\u5B9A\u9700\u8981\u4E0B\u8F7D\u7684\u955C\u50CF\u540D\u79F0\u3002"));
+        console.error(pc11.red("\u274C \u9519\u8BEF: \u672A\u6307\u5B9A\u9700\u8981\u4E0B\u8F7D\u7684\u955C\u50CF\u540D\u79F0\u3002"));
         cmd.outputHelp();
         return;
       }
@@ -1621,7 +1749,7 @@ function registerParkCommand(program2) {
 }
 
 // commands/proxy.ts
-import pc11 from "picocolors";
+import pc12 from "picocolors";
 function registerProxyCommand(program2) {
   program2.command("proxy [action] [port]").description(
     "\u7BA1\u7406\u7EC8\u7AEF\u4E34\u65F6\u4EE3\u7406 (\u652F\u6301 proxy on [port] \u6216 proxy off\uFF0C\u65E0\u53C2\u6570\u65F6\u67E5\u770B\u5F53\u524D\u72B6\u6001)"
@@ -1629,29 +1757,29 @@ function registerProxyCommand(program2) {
     if (action === "on") {
       const p = port || "7890";
       console.log(
-        pc11.yellow(
+        pc12.yellow(
           `\u26A0\uFE0F  \u8B66\u544A: \u76F4\u63A5\u8FD0\u884C\u4E8C\u8FDB\u5236\u65E0\u6CD5\u76F4\u63A5\u4FEE\u6539\u5F53\u524D\u7EC8\u7AEF\u7684\u4E3B\u73AF\u5883\u53D8\u91CF\u3002`
         )
       );
-      console.log(pc11.cyan(`\u{1F449} \u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u624B\u52A8\u542F\u7528\u4EE3\u7406\uFF1A`));
-      console.log(pc11.bold(`   export http_proxy="http://127.0.0.1:${p}"`));
-      console.log(pc11.bold(`   export https_proxy="http://127.0.0.1:${p}"`));
-      console.log(pc11.bold(`   export all_proxy="socks5://127.0.0.1:${p}"`));
+      console.log(pc12.cyan(`\u{1F449} \u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u624B\u52A8\u542F\u7528\u4EE3\u7406\uFF1A`));
+      console.log(pc12.bold(`   export http_proxy="http://127.0.0.1:${p}"`));
+      console.log(pc12.bold(`   export https_proxy="http://127.0.0.1:${p}"`));
+      console.log(pc12.bold(`   export all_proxy="socks5://127.0.0.1:${p}"`));
       console.log(
-        pc11.dim(
+        pc12.dim(
           `
 \u{1F4A1} \u63D0\u793A\uFF1A\u6267\u884C\u4E00\u6B21 'xx completion' \u5E76\u91CD\u5F00\u7EC8\u7AEF\u540E\uFF0C\u5373\u53EF\u76F4\u63A5\u8FD0\u884C 'xx proxy on' \u4E00\u952E\u5F00\u542F\uFF01`
         )
       );
     } else if (action === "off") {
       console.log(
-        pc11.yellow(
+        pc12.yellow(
           `\u26A0\uFE0F  \u8B66\u544A: \u76F4\u63A5\u8FD0\u884C\u4E8C\u8FDB\u5236\u65E0\u6CD5\u76F4\u63A5\u4FEE\u6539\u5F53\u524D\u7EC8\u7AEF\u7684\u4E3B\u73AF\u5883\u53D8\u91CF\u3002`
         )
       );
-      console.log(pc11.cyan(`\u{1F449} \u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u624B\u52A8\u5173\u95ED\u4EE3\u7406\uFF1A`));
+      console.log(pc12.cyan(`\u{1F449} \u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u624B\u52A8\u5173\u95ED\u4EE3\u7406\uFF1A`));
       console.log(
-        pc11.bold(
+        pc12.bold(
           `   unset http_proxy https_proxy all_proxy HTTP_PROXY HTTPS_PROXY ALL_PROXY`
         )
       );
@@ -1660,15 +1788,15 @@ function registerProxyCommand(program2) {
       const httpsProxy = process.env["https_proxy"] || process.env["HTTPS_PROXY"];
       const allProxy = process.env["all_proxy"] || process.env["ALL_PROXY"];
       if (httpProxy || httpsProxy || allProxy) {
-        console.log(pc11.yellow("\u{1F50D} [xx] \u68C0\u6D4B\u5230\u5F53\u524D\u7EC8\u7AEF\u5DF2\u914D\u7F6E\u4E34\u65F6\u4EE3\u7406\uFF1A"));
-        if (httpProxy) console.log(`  http_proxy  = ${pc11.bold(httpProxy)}`);
-        if (httpsProxy) console.log(`  https_proxy = ${pc11.bold(httpsProxy)}`);
-        if (allProxy) console.log(`  all_proxy   = ${pc11.bold(allProxy)}`);
+        console.log(pc12.yellow("\u{1F50D} [xx] \u68C0\u6D4B\u5230\u5F53\u524D\u7EC8\u7AEF\u5DF2\u914D\u7F6E\u4E34\u65F6\u4EE3\u7406\uFF1A"));
+        if (httpProxy) console.log(`  http_proxy  = ${pc12.bold(httpProxy)}`);
+        if (httpsProxy) console.log(`  https_proxy = ${pc12.bold(httpsProxy)}`);
+        if (allProxy) console.log(`  all_proxy   = ${pc12.bold(allProxy)}`);
       } else {
-        console.log(pc11.green("\u{1F50D} [xx] \u5F53\u524D\u7EC8\u7AEF\u672A\u914D\u7F6E\u4EFB\u4F55\u4EE3\u7406 (\u76F4\u8FDE\u6A21\u5F0F)"));
+        console.log(pc12.green("\u{1F50D} [xx] \u5F53\u524D\u7EC8\u7AEF\u672A\u914D\u7F6E\u4EFB\u4F55\u4EE3\u7406 (\u76F4\u8FDE\u6A21\u5F0F)"));
       }
       console.log(
-        pc11.dim(
+        pc12.dim(
           "\n\u{1F4A1} \u63D0\u793A\uFF1A\u60A8\u53EF\u4EE5\u4F7F\u7528 'xx proxy on [port]' \u5F00\u542F\u6216 'xx proxy off' \u5173\u95ED\u4E34\u65F6\u4EE3\u7406\u3002"
         )
       );
@@ -1677,15 +1805,15 @@ function registerProxyCommand(program2) {
 }
 
 // commands/remove.ts
-import fs10 from "fs/promises";
-import pc12 from "picocolors";
+import fs11 from "fs/promises";
+import pc13 from "picocolors";
 import { resolve as resolve9 } from "path";
 import fg from "fast-glob";
 import trash from "trash";
 function registerRemoveCommand(program2) {
   program2.command("remove <paths...>").description("\u5B89\u5168\u5730\u5C06\u6307\u5B9A\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u79FB\u81F3\u7CFB\u7EDF\u56DE\u6536\u7AD9\uFF08\u652F\u6301\u901A\u914D\u7B26\u53CA\u591A\u9009\uFF09").action(async (paths) => {
     if (!paths || paths.length === 0) {
-      console.error(pc12.red("\u274C \u8BF7\u63D0\u4F9B\u8981\u653E\u5165\u56DE\u6536\u7AD9\u7684\u8DEF\u5F84\u6216\u901A\u914D\u7B26\u89C4\u5219"));
+      console.error(pc13.red("\u274C \u8BF7\u63D0\u4F9B\u8981\u653E\u5165\u56DE\u6536\u7AD9\u7684\u8DEF\u5F84\u6216\u901A\u914D\u7B26\u89C4\u5219"));
       return;
     }
     const resolvedPathsToDelete = /* @__PURE__ */ new Set();
@@ -1705,21 +1833,21 @@ function registerRemoveCommand(program2) {
           }
         } catch (err) {
           console.error(
-            pc12.red(`\u274C \u5339\u914D\u901A\u914D\u7B26 '${pattern}' \u65F6\u53D1\u751F\u5F02\u5E38:`),
+            pc13.red(`\u274C \u5339\u914D\u901A\u914D\u7B26 '${pattern}' \u65F6\u53D1\u751F\u5F02\u5E38:`),
             err instanceof Error ? err.message : err
           );
         }
       } else {
         const absolutePath = resolve9(process.cwd(), pattern);
         try {
-          await fs10.stat(absolutePath);
+          await fs11.stat(absolutePath);
           resolvedPathsToDelete.add(absolutePath);
         } catch (err) {
           if (isNotFoundError(err)) {
             notFoundPaths.push(absolutePath);
           } else {
             console.error(
-              pc12.red(`\u274C \u83B7\u53D6\u8DEF\u5F84\u72B6\u6001\u5931\u8D25 [${pattern}]:`),
+              pc13.red(`\u274C \u83B7\u53D6\u8DEF\u5F84\u72B6\u6001\u5931\u8D25 [${pattern}]:`),
               err instanceof Error ? err.message : err
             );
           }
@@ -1728,31 +1856,31 @@ function registerRemoveCommand(program2) {
     }
     if (notFoundPaths.length > 0) {
       for (const path of notFoundPaths) {
-        console.error(pc12.red(`\u274C \u8DEF\u5F84\u4E0D\u5B58\u5728: ${path}`));
+        console.error(pc13.red(`\u274C \u8DEF\u5F84\u4E0D\u5B58\u5728: ${path}`));
       }
     }
     if (resolvedPathsToDelete.size === 0) {
-      console.log(pc12.yellow("\u2139\uFE0F \u672A\u80FD\u627E\u5230\u4EFB\u4F55\u4E0E\u6307\u5B9A\u6761\u4EF6\u5339\u914D\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u3002"));
+      console.log(pc13.yellow("\u2139\uFE0F \u672A\u80FD\u627E\u5230\u4EFB\u4F55\u4E0E\u6307\u5B9A\u6761\u4EF6\u5339\u914D\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u3002"));
       return;
     }
     try {
       console.log(
-        pc12.cyan(
+        pc13.cyan(
           `\u{1F4E6} \u6B63\u5728\u5C06 ${resolvedPathsToDelete.size} \u4E2A\u9879\u79FB\u81F3\u7CFB\u7EDF\u56DE\u6536\u7AD9...`
         )
       );
       await trash(Array.from(resolvedPathsToDelete));
       for (const path of resolvedPathsToDelete) {
-        console.log(pc12.dim(`  - \u5DF2\u79FB\u5165\u5783\u573E\u7BB1: ${path}`));
+        console.log(pc13.dim(`  - \u5DF2\u79FB\u5165\u5783\u573E\u7BB1: ${path}`));
       }
       console.log(
-        pc12.green(
+        pc13.green(
           `\u2728 \u6210\u529F\uFF01\u5171 ${resolvedPathsToDelete.size} \u4E2A\u6587\u4EF6/\u76EE\u5F55\u5DF2\u5B89\u5168\u9001\u81F3\u7CFB\u7EDF\u56DE\u6536\u7AD9\u3002`
         )
       );
     } catch (err) {
       console.error(
-        pc12.red("\u274C \u79FB\u81F3\u56DE\u6536\u7AD9\u5931\u8D25:"),
+        pc13.red("\u274C \u79FB\u81F3\u56DE\u6536\u7AD9\u5931\u8D25:"),
         err instanceof Error ? err.message : err
       );
     }
@@ -1760,32 +1888,32 @@ function registerRemoveCommand(program2) {
 }
 
 // commands/search.ts
-import fs11 from "fs/promises";
-import pc13 from "picocolors";
-import { resolve as resolve10, basename as basename4, relative } from "path";
+import fs12 from "fs/promises";
+import pc14 from "picocolors";
+import { resolve as resolve10, basename as basename5, relative } from "path";
 import fg2 from "fast-glob";
 function registerSearchCommand(program2) {
   program2.command("search <keyword> [directory]").description(
     "\u9012\u5F52\u641C\u7D22\u76EE\u5F55\u4E0B\u5305\u542B\u6307\u5B9A\u5173\u952E\u8BCD\u7684\u6587\u4EF6\u6216\u76EE\u5F55\uFF08\u652F\u6301 Ctrl+\u70B9\u51FB \u5FEB\u6377\u6253\u5F00\uFF09"
   ).action(async (keyword, directory) => {
     if (!keyword) {
-      console.error(pc13.red("\u274C \u8BF7\u63D0\u4F9B\u8981\u641C\u7D22\u7684\u6587\u4EF6\u540D\u5173\u952E\u8BCD"));
+      console.error(pc14.red("\u274C \u8BF7\u63D0\u4F9B\u8981\u641C\u7D22\u7684\u6587\u4EF6\u540D\u5173\u952E\u8BCD"));
       return;
     }
     const startDir = directory || ".";
     const absoluteStartDir = resolve10(process.cwd(), startDir);
     try {
-      const stat = await fs11.stat(absoluteStartDir);
+      const stat = await fs12.stat(absoluteStartDir);
       if (!stat.isDirectory()) {
-        console.error(pc13.red(`\u274C \u9519\u8BEF: '${startDir}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
+        console.error(pc14.red(`\u274C \u9519\u8BEF: '${startDir}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
         return;
       }
     } catch {
-      console.error(pc13.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u8D77\u70B9\u76EE\u5F55 '${startDir}'\u3002`));
+      console.error(pc14.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u8D77\u70B9\u76EE\u5F55 '${startDir}'\u3002`));
       return;
     }
     console.log(
-      pc13.cyan(
+      pc14.cyan(
         `\u{1F50D} \u6B63\u5728\u76EE\u5F55 ${absoluteStartDir} \u4E2D\u9012\u5F52\u641C\u5BFB\u5305\u542B "${keyword}" \u7684\u9879\u76EE...
 `
       )
@@ -1806,30 +1934,30 @@ function registerSearchCommand(program2) {
         ]
       });
       for (const entryPath of entries) {
-        const name = basename4(entryPath);
+        const name = basename5(entryPath);
         if (name.toLowerCase().includes(keyword.toLowerCase())) {
           matchCount++;
           const relativePath = relative(absoluteStartDir, entryPath);
           const isDirectory = !name.includes(".") || entryPath.endsWith("/");
           let isDir = isDirectory;
           try {
-            const entryStat = await fs11.stat(entryPath);
+            const entryStat = await fs12.stat(entryPath);
             isDir = entryStat.isDirectory();
           } catch {
           }
           const typeIcon = isDir ? "\u{1F4C1}" : "\u{1F4C4}";
           const fileUri = `file://${entryPath}`;
-          const hyperlink = `\x1B]8;;${fileUri}\x1B\\${pc13.bold(name)}\x1B]8;;\x1B\\`;
-          console.log(`${typeIcon} ${hyperlink}  ->  ${pc13.dim(fileUri)}`);
+          const hyperlink = `\x1B]8;;${fileUri}\x1B\\${pc14.bold(name)}\x1B]8;;\x1B\\`;
+          console.log(`${typeIcon} ${hyperlink}  ->  ${pc14.dim(fileUri)}`);
         }
       }
       console.log(
-        pc13.green(`
+        pc14.green(`
 \u2728 \u641C\u7D22\u5B8C\u6210\uFF01\u5171\u627E\u5230 ${matchCount} \u4E2A\u5339\u914D\u7684\u9879\u76EE\u3002`)
       );
     } catch (err) {
       console.error(
-        pc13.red("\u274C \u641C\u5BFB\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF:"),
+        pc14.red("\u274C \u641C\u5BFB\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF:"),
         err instanceof Error ? err.message : err
       );
     }
@@ -1837,7 +1965,7 @@ function registerSearchCommand(program2) {
 }
 
 // commands/translate.ts
-import pc14 from "picocolors";
+import pc15 from "picocolors";
 import { translate } from "google-translate-api-x";
 import readline from "readline";
 import process3 from "process";
@@ -1854,13 +1982,13 @@ async function performTranslation(text, userSpecifiedLang) {
       to: targetLang
     });
     console.log(
-      `${pc14.green("\u8BD1\u6587:")} ${pc14.bold(res.text)} ${pc14.dim(`(${res.from.language.iso} -> ${targetLang})`)}`
+      `${pc15.green("\u8BD1\u6587:")} ${pc15.bold(res.text)} ${pc15.dim(`(${res.from.language.iso} -> ${targetLang})`)}`
     );
   } catch (err) {
     if (err instanceof Error) {
-      console.error(pc14.red("\u274C \u7FFB\u8BD1\u51FA\u9519:"), err.message);
+      console.error(pc15.red("\u274C \u7FFB\u8BD1\u51FA\u9519:"), err.message);
     } else {
-      console.error(pc14.red("\u274C \u7FFB\u8BD1\u51FA\u9519:"), String(err));
+      console.error(pc15.red("\u274C \u7FFB\u8BD1\u51FA\u9519:"), String(err));
     }
   }
 }
@@ -1868,11 +1996,11 @@ function startInteractiveMode(userSpecifiedLang) {
   const rl = readline.createInterface({
     input: process3.stdin,
     output: process3.stdout,
-    prompt: pc14.cyan("\u7FFB\u8BD1\u8F93\u5165 > ")
+    prompt: pc15.cyan("\u7FFB\u8BD1\u8F93\u5165 > ")
   });
   const modeTip = userSpecifiedLang === "auto" ? "\u667A\u80FD\u81EA\u52A8\u8BC6\u522B" : `\u5F3A\u5236\u76EE\u6807\u8BED\u8A00: ${userSpecifiedLang}`;
-  console.log(pc14.yellow(`\u2728 \u5DF2\u8FDB\u5165\u4EA4\u4E92\u6A21\u5F0F (${modeTip})`));
-  console.log(pc14.dim('\u8F93\u5165 "exit" \u6216\u6309 Ctrl+C \u9000\u51FA\n'));
+  console.log(pc15.yellow(`\u2728 \u5DF2\u8FDB\u5165\u4EA4\u4E92\u6A21\u5F0F (${modeTip})`));
+  console.log(pc15.dim('\u8F93\u5165 "exit" \u6216\u6309 Ctrl+C \u9000\u51FA\n'));
   rl.prompt();
   rl.on("line", async (line) => {
     const input = line.trim();
@@ -1886,7 +2014,7 @@ function startInteractiveMode(userSpecifiedLang) {
     console.log();
     rl.prompt();
   }).on("close", () => {
-    console.log(pc14.blue("\n\u518D\u89C1!"));
+    console.log(pc15.blue("\n\u518D\u89C1!"));
     process3.exit(0);
   });
 }
@@ -1905,464 +2033,33 @@ function registerTanslateCommand(program2) {
 }
 
 // commands/uninstall.ts
-import fs12 from "fs/promises";
-import pc15 from "picocolors";
-import { resolve as resolve11, join as join7 } from "path";
-function getHomeDir2() {
-  return process.env["HOME"] || process.env["USERPROFILE"] || process.cwd();
-}
-async function isSnapInstalled(packageName) {
-  if (!await isCommandAvailable("snap")) return false;
-  try {
-    const { success } = await runCommand("snap", ["list", packageName]);
-    return success;
-  } catch {
-    return false;
-  }
-}
-async function isSystemPackageInstalled(packageName) {
-  try {
-    const osRelease = await fs12.readFile("/etc/os-release", "utf-8");
-    if (osRelease.includes("fedora") || osRelease.includes("rhel") || osRelease.includes("centos")) {
-      const { success } = await runCommand("rpm", ["-q", packageName]);
-      return success;
-    } else {
-      const { success, stdout } = await runCommand("dpkg-query", [
-        "-W",
-        "-f=${Status}",
-        packageName
-      ]);
-      if (success) {
-        const status = decodeOutput(stdout).trim();
-        return status.includes("installed");
-      }
-      return false;
-    }
-  } catch {
-    return false;
-  }
-}
-async function findGreenAppPath(appName) {
-  const home = getHomeDir2();
-  const greenAppDir = join7(home, "GreenApp");
-  const dirPath = join7(greenAppDir, appName);
-  try {
-    const stat = await fs12.stat(dirPath);
-    if (stat.isDirectory()) return dirPath;
-  } catch {
-  }
-  const appImagePath = join7(greenAppDir, `${appName}.AppImage`);
-  const appImageLowerPath = join7(greenAppDir, `${appName}.appimage`);
-  try {
-    const stat = await fs12.stat(appImagePath);
-    if (stat.isFile()) return appImagePath;
-  } catch {
-    try {
-      const stat = await fs12.stat(appImageLowerPath);
-      if (stat.isFile()) return appImageLowerPath;
-    } catch {
-    }
-  }
-  if (appName.toLowerCase().endsWith(".appimage")) {
-    const directPath = join7(greenAppDir, appName);
-    try {
-      const stat = await fs12.stat(directPath);
-      if (stat.isFile()) return directPath;
-    } catch {
-    }
-  }
-  return null;
-}
-async function extractDebPackageName(absPath) {
-  try {
-    const { success, stdout } = await runCommand("dpkg-deb", [
-      "-f",
-      absPath,
-      "Package"
-    ]);
-    if (success) {
-      return decodeOutput(stdout).trim();
-    }
-  } catch {
-  }
-  return void 0;
-}
-async function extractRpmPackageName(absPath) {
-  try {
-    const { success, stdout } = await runCommand("rpm", [
-      "-qp",
-      "--queryformat",
-      "%{NAME}",
-      absPath
-    ]);
-    if (success) {
-      return decodeOutput(stdout).trim();
-    }
-  } catch {
-  }
-  return void 0;
-}
-async function searchGreenApps(query) {
-  const home = getHomeDir2();
-  const greenAppDir = join7(home, "GreenApp");
-  const candidates = [];
-  try {
-    for (const entry of await fs12.readdir(greenAppDir, {
-      withFileTypes: true
-    })) {
-      if (entry.name.toLowerCase().includes(query.toLowerCase())) {
-        candidates.push(entry.name.replace(/\.appimage/i, ""));
-      }
-    }
-  } catch {
-  }
-  return candidates;
-}
-async function searchFlatpaks(query) {
-  const candidates = [];
-  if (!await isCommandAvailable("flatpak")) return candidates;
-  try {
-    const { success, stdout } = await runCommand("flatpak", [
-      "list",
-      "--columns=application,name"
-    ]);
-    if (success) {
-      const output = decodeOutput(stdout).trim();
-      const lines = output.split("\n");
-      for (const line of lines) {
-        const parts = line.split("	").map((p) => p.trim());
-        if (parts.length >= 2) {
-          const [id, name] = parts;
-          if (id.toLowerCase().includes(query.toLowerCase()) || name.toLowerCase().includes(query.toLowerCase())) {
-            candidates.push({ id, name });
-          }
-        }
-      }
-    }
-  } catch {
-  }
-  return candidates;
-}
-async function searchDebPackages(query) {
-  const pkgs = [];
-  try {
-    const { success, stdout } = await runCommand("dpkg-query", [
-      "-W",
-      "-f=${Package}\n",
-      `*${query}*`
-    ]);
-    if (success) {
-      const output = decodeOutput(stdout).trim();
-      const lines = output.split("\n");
-      for (const line of lines) {
-        const name = line.trim();
-        if (name && !name.startsWith("-f=")) {
-          pkgs.push(name);
-        }
-      }
-    }
-  } catch {
-  }
-  return pkgs;
-}
-async function searchRpmPackages(query) {
-  const pkgs = [];
-  try {
-    const { success, stdout } = await runCommand("rpm", [
-      "-qa",
-      "--queryformat",
-      "%{NAME}\n",
-      `*${query}*`
-    ]);
-    if (success) {
-      const output = decodeOutput(stdout).trim();
-      const lines = output.split("\n");
-      const uniquePkgs = /* @__PURE__ */ new Set();
-      for (const line of lines) {
-        const name = line.trim();
-        if (name) {
-          uniquePkgs.add(name);
-        }
-      }
-      pkgs.push(...uniquePkgs);
-    }
-  } catch {
-  }
-  return pkgs;
-}
-async function removeDeb(packageName) {
-  console.log(pc15.cyan(`\u{1F4E6} \u6B63\u5728\u901A\u8FC7 apt \u5378\u8F7D DEB \u8F6F\u4EF6\u5305: ${packageName}...`));
-  const status = await spawnCommand("sudo", [
-    "apt-get",
-    "remove",
-    "-y",
-    packageName
-  ]);
-  if (status.success) {
-    console.log(pc15.green(`\u2714 \u8F6F\u4EF6\u5305 ${packageName} \u5DF2\u6210\u529F\u4ECE\u7CFB\u7EDF\u4E2D\u79FB\u9664\u3002`));
-  } else {
-    console.error(pc15.red(`\u274C \u5378\u8F7D\u5931\u8D25\uFF0C\u8FDB\u7A0B\u9000\u51FA\u7801: ${status.code}`));
-  }
-}
-async function removeRpm(packageName) {
-  console.log(pc15.cyan(`\u{1F4E6} \u6B63\u5728\u901A\u8FC7 dnf \u5378\u8F7D RPM \u8F6F\u4EF6\u5305: ${packageName}...`));
-  const status = await spawnCommand("sudo", [
-    "dnf",
-    "remove",
-    "-y",
-    packageName
-  ]);
-  if (status.success) {
-    console.log(pc15.green(`\u2714 \u8F6F\u4EF6\u5305 ${packageName} \u5DF2\u6210\u529F\u4ECE\u7CFB\u7EDF\u4E2D\u79FB\u9664\u3002`));
-  } else {
-    console.error(pc15.red(`\u274C \u5378\u8F7D\u5931\u8D25\uFF0C\u8FDB\u7A0B\u9000\u51FA\u7801: ${status.code}`));
-  }
-}
-async function removeSnap(packageName) {
-  console.log(pc15.cyan(`\u{1F4E6} \u6B63\u5728\u901A\u8FC7 snap \u5378\u8F7D\u8F6F\u4EF6\u5305: ${packageName}...`));
-  const status = await spawnCommand("sudo", ["snap", "remove", packageName]);
-  if (status.success) {
-    console.log(pc15.green(`\u2714 Snap \u8F6F\u4EF6\u5305 ${packageName} \u5DF2\u6210\u529F\u4ECE\u7CFB\u7EDF\u4E2D\u79FB\u9664\u3002`));
-  } else {
-    console.error(pc15.red(`\u274C \u5378\u8F7D\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${status.code}`));
-  }
-}
-async function uninstallFlatpak(packageName) {
-  if (!await isCommandAvailable("flatpak")) {
-    console.error(pc15.red("\u274C \u5F53\u524D\u7CFB\u7EDF\u4E2D\u672A\u68C0\u6D4B\u5230\u5DF2\u5B89\u88C5\u7684 flatpak \u5DE5\u5177\u3002"));
-    return;
-  }
-  console.log(pc15.cyan(`\u{1F4E6} \u6B63\u5728\u901A\u8FC7 flatpak \u5378\u8F7D\u5E94\u7528: ${packageName}...`));
-  const status = await spawnCommand("flatpak", [
-    "uninstall",
-    "-y",
-    packageName
-  ]);
-  if (status.success) {
-    const home = getHomeDir2();
-    const desktopPath = join7(
-      home,
-      ".local/share/applications",
-      `flatpak-${packageName}.desktop`
-    );
-    try {
-      await fs12.rm(desktopPath);
-      console.log(pc15.green(`\u2714 \u5DF2\u6E05\u9664 Flatpak \u5173\u8054\u684C\u9762\u5FEB\u6377\u56FE\u6807\u3002`));
-    } catch {
-    }
-    console.log(pc15.green("\u2728 Flatpak \u5E94\u7528\u53CA\u56FE\u6807\u6E05\u7406\u5B8C\u6210\uFF01"));
-  }
-}
-async function performRemoveGreenApp(greenPath, appName) {
-  const home = getHomeDir2();
-  const applicationsDir = join7(home, ".local/share/applications");
-  try {
-    for (const entry of await fs12.readdir(applicationsDir, {
-      withFileTypes: true
-    })) {
-      if (entry.isFile() && entry.name.endsWith(".desktop")) {
-        const filePath = join7(applicationsDir, entry.name);
-        const content = await fs12.readFile(filePath, "utf-8");
-        if (content.includes(greenPath) || content.includes(appName)) {
-          await fs12.rm(filePath);
-          console.log(pc15.green(`\u2714 \u5DF2\u6E05\u9664\u684C\u9762\u5FEB\u6377\u56FE\u6807: ${filePath}`));
-        }
-      }
+import pc16 from "picocolors";
+function registerUninstallCommand(program2) {
+  program2.command("uninstall <package>").description("macOS/Windows \u672C\u5730\u5DE5\u5177\u5378\u8F7D\u5668\uFF08\u79FB\u9664\u5B89\u88C5\u76EE\u5F55\u548C\u7EC8\u7AEF\u547D\u4EE4\u5165\u53E3\uFF09").action(async (pkg) => {
+    if (!ensureSupportedDesktopOS()) return;
+    if (!pkg) {
+      console.error(pc16.red("\u274C \u8BF7\u63D0\u4F9B\u8981\u5378\u8F7D\u7684\u5E94\u7528\u540D\u3002"));
+      return;
     }
-  } catch {
-  }
-  try {
-    await fs12.rm(greenPath, { recursive: true });
-    console.log(pc15.green(`\u2714 \u5DF2\u6210\u529F\u6E05\u9664\u7EFF\u8272\u8F6F\u4EF6\u4E3B\u4F53: ${greenPath}`));
-  } catch (err) {
-    console.error(
-      pc15.red(`\u274C \u6E05\u9664\u8F6F\u4EF6\u4E3B\u4F53\u5931\u8D25:`),
-      err instanceof Error ? err.message : err
-    );
-  }
-}
-async function performFuzzySearchAndRecommendation(query) {
-  const hasSnap = await isCommandAvailable("snap");
-  const [greenCands, flatpakCands, snapCands] = await Promise.all([
-    searchGreenApps(query),
-    searchFlatpaks(query),
-    hasSnap ? (async () => {
-      const candidates = [];
-      try {
-        const { success, stdout } = await runCommand("snap", ["list"]);
-        if (success) {
-          const lines = decodeOutput(stdout).split("\n");
-          for (let i = 1; i < lines.length; i++) {
-            const name = lines[i].trim().split(/\s+/)[0];
-            if (name && name.toLowerCase().includes(query.toLowerCase())) {
-              candidates.push(name);
-            }
-          }
-        }
-      } catch {
-      }
-      return candidates;
-    })() : Promise.resolve([])
-  ]);
-  let systemCands = [];
-  try {
-    const osRelease = await fs12.readFile("/etc/os-release", "utf-8");
-    if (osRelease.includes("fedora") || osRelease.includes("rhel") || osRelease.includes("centos")) {
-      systemCands = await searchRpmPackages(query);
-    } else {
-      systemCands = await searchDebPackages(query);
+    const removed = await removeInstalledApp(pkg);
+    if (removed) {
+      console.log(pc16.green("\u2728 \u5378\u8F7D\u5B8C\u6210\uFF01\u76F8\u5173\u7EC8\u7AEF\u547D\u4EE4\u5165\u53E3\u4E5F\u5DF2\u6E05\u7406\u3002"));
+      return;
     }
-  } catch {
-    systemCands = await searchDebPackages(query);
-  }
-  const totalCands = greenCands.length + flatpakCands.length + snapCands.length + systemCands.length;
-  if (totalCands > 0) {
-    console.log(
-      pc15.cyan(
-        `\u{1F4A1} \u5E2E\u60A8\u5728\u7CFB\u7EDF\u4E2D\u641C\u5BFB\u5230\u4EE5\u4E0B ${totalCands} \u4E2A\u5305\u542B "${query}" \u7684\u76F8\u5173\u5339\u914D\u9879\uFF1A
-`
-      )
+    const candidates = (await listInstalledApps()).filter(
+      (name) => name.toLowerCase().includes(pkg.toLowerCase())
     );
-    if (greenCands.length > 0) {
-      console.log(pc15.bold(pc15.green("\u{1F4C1} [\u7EFF\u8272\u5E94\u7528] \u5019\u9009\uFF1A")));
-      for (const cand of greenCands) {
-        console.log(
-          `  - ${cand}  ${pc15.dim(`(\u5378\u8F7D\u547D\u4EE4: xx uninstall ${cand})`)}`
-        );
-      }
-    }
-    if (flatpakCands.length > 0) {
-      console.log(pc15.bold(pc15.magenta("\n\u{1F4E6} [Flatpak] \u5019\u9009\uFF1A")));
-      for (const cand of flatpakCands) {
-        console.log(
-          `  - ${cand.id} [${cand.name}]  ${pc15.dim(`(\u5378\u8F7D\u547D\u4EE4: xx uninstall ${cand.id})`)}`
-        );
-      }
-    }
-    if (snapCands.length > 0) {
-      console.log(pc15.bold(pc15.yellow("\n\u26A1 [Snap] \u5019\u9009\uFF1A")));
-      for (const cand of snapCands) {
-        console.log(
-          `  - ${cand}  ${pc15.dim(`(\u5378\u8F7D\u547D\u4EE4: xx uninstall ${cand})`)}`
-        );
-      }
-    }
-    if (systemCands.length > 0) {
-      console.log(pc15.bold(pc15.blue("\n\u2699 [\u7CFB\u7EDF\u6E90\u7EA7] \u5019\u9009\uFF1A")));
-      for (const cand of systemCands) {
+    if (candidates.length > 0) {
+      console.log(pc16.yellow("\u274C \u672A\u627E\u5230\u7CBE\u786E\u5339\u914D\u7684\u5DF2\u5B89\u88C5\u5E94\u7528\u3002"));
+      console.log(pc16.cyan("\u4F60\u53EF\u80FD\u60F3\u5378\u8F7D\u4EE5\u4E0B\u9879\u76EE\uFF1A"));
+      for (const candidate of candidates) {
         console.log(
-          `  - ${cand}  ${pc15.dim(`(\u5378\u8F7D\u547D\u4EE4: xx uninstall ${cand})`)}`
+          `  - ${candidate}  ${pc16.dim(`(xx uninstall ${candidate})`)}`
         );
       }
-    }
-    console.log(pc15.cyan(`
-\u{1F3C1} \u641C\u5BFB\u5B8C\u6210\uFF01`));
-  }
-}
-async function parseUninstallTarget(target) {
-  const lower = target.toLowerCase();
-  const greenPath = await findGreenAppPath(target);
-  if (greenPath) {
-    return { type: "green", raw: target, greenPath };
-  }
-  const isFlatpak = !target.includes("/") && !target.includes("\\") && target.split(".").length >= 3;
-  if (isFlatpak) {
-    return { type: "flatpak", raw: target };
-  }
-  if (lower.endsWith(".deb")) {
-    const absPath = resolve11(process.cwd(), target);
-    try {
-      const stat = await fs12.stat(absPath);
-      if (stat.isFile()) {
-        const extractedPackageName = await extractDebPackageName(absPath);
-        return {
-          type: "deb",
-          raw: target,
-          resolvedPath: absPath,
-          extractedPackageName
-        };
-      }
-    } catch {
-    }
-  }
-  if (lower.endsWith(".rpm")) {
-    const absPath = resolve11(process.cwd(), target);
-    try {
-      const stat = await fs12.stat(absPath);
-      if (stat.isFile()) {
-        const extractedPackageName = await extractRpmPackageName(absPath);
-        return {
-          type: "rpm",
-          raw: target,
-          resolvedPath: absPath,
-          extractedPackageName
-        };
-      }
-    } catch {
-    }
-  }
-  if (await isSnapInstalled(target)) {
-    return { type: "snap", raw: target };
-  }
-  if (await isSystemPackageInstalled(target)) {
-    return { type: "system", raw: target };
-  }
-  return { type: "unknown", raw: target };
-}
-function registerUninstallCommand(program2) {
-  program2.command("uninstall <package>").description("\u901A\u7528\u5E94\u7528\u5378\u8F7D\u5668\uFF08\u652F\u6301\u5305\u540D\u3001Flatpak\u3001Snap\u3001\u672C\u5730\u5305\u6216\u7EFF\u8272\u8F6F\u4EF6\uFF09").action(async (pkg) => {
-    if (!pkg) {
-      console.error(
-        pc15.red("\u274C \u8BF7\u63D0\u4F9B\u8981\u5378\u8F7D\u7684\u8F6F\u4EF6\u5305\u540D\u79F0\u3001\u5B89\u88C5\u5305\u6216\u7EFF\u8272\u8F6F\u4EF6\u540D\u3002")
-      );
-      return;
-    }
-    try {
-      const parsed = await parseUninstallTarget(pkg);
-      switch (parsed.type) {
-        case "green":
-          await performRemoveGreenApp(parsed.greenPath, parsed.raw);
-          console.log(pc15.green("\u2728 \u7EFF\u8272\u5E94\u7528\u53CA\u684C\u9762\u5FEB\u6377\u65B9\u5F0F\u6E05\u7406\u5B8C\u6210\uFF01"));
-          break;
-        case "flatpak":
-          await uninstallFlatpak(parsed.raw);
-          break;
-        case "snap":
-          await removeSnap(parsed.raw);
-          break;
-        case "deb": {
-          const debPkgName = parsed.extractedPackageName || parsed.raw;
-          await removeDeb(debPkgName);
-          break;
-        }
-        case "rpm": {
-          const rpmPkgName = parsed.extractedPackageName || parsed.raw;
-          await removeRpm(rpmPkgName);
-          break;
-        }
-        case "system": {
-          const osRelease = await fs12.readFile("/etc/os-release", "utf-8");
-          if (osRelease.includes("fedora") || osRelease.includes("rhel") || osRelease.includes("centos")) {
-            await removeRpm(parsed.raw);
-          } else {
-            await removeDeb(parsed.raw);
-          }
-          break;
-        }
-        case "unknown":
-          await performFuzzySearchAndRecommendation(parsed.raw);
-          break;
-        default: {
-          const _exhaustiveCheck = parsed;
-          throw new Error(
-            `\u672A\u5904\u7406\u7684\u5378\u8F7D\u5206\u652F\u7C7B\u578B: ${JSON.stringify(_exhaustiveCheck)}`
-          );
-        }
-      }
-    } catch (err) {
+    } else {
       console.error(
-        pc15.red("\u274C \u5378\u8F7D\u90E8\u7F72\u5931\u8D25:"),
-        err instanceof Error ? err.message : String(err)
+        pc16.red(`\u274C \u672A\u627E\u5230\u5DF2\u5B89\u88C5\u5E94\u7528 '${pkg}'\u3002\u8BF7\u5148\u8FD0\u884C xx install \u5B89\u88C5\u3002`)
       );
     }
   });
@@ -2370,37 +2067,12 @@ function registerUninstallCommand(program2) {
 
 // commands/unzip.ts
 import fs13 from "fs/promises";
-import pc16 from "picocolors";
-import { join as join8, basename as basename6, extname, resolve as resolve12 } from "path";
-
-// utils/archive.ts
-import AdmZip from "adm-zip";
-import * as tar from "tar";
-import { mkdir } from "fs/promises";
-async function compressZip(sourceDir, outputPath) {
-  const zip = new AdmZip();
-  zip.addLocalFolder(sourceDir);
-  zip.writeZip(outputPath);
-}
-async function uncompressZip(src, destDir) {
-  await mkdir(destDir, { recursive: true });
-  const zip = new AdmZip(src);
-  zip.extractAllTo(destDir, true);
-}
-async function uncompressTar(src, destDir) {
-  await mkdir(destDir, { recursive: true });
-  await tar.x({ file: src, cwd: destDir });
-}
-async function uncompressTgz(src, destDir) {
-  await mkdir(destDir, { recursive: true });
-  await tar.x({ file: src, gzip: true, cwd: destDir });
-}
-
-// commands/unzip.ts
+import pc17 from "picocolors";
+import { join as join8, basename as basename6, extname as extname2, resolve as resolve11 } from "path";
 async function uncompressRar(src, dest) {
   const hasUnrar = isCommandAvailable("unrar");
   if (hasUnrar) {
-    console.log(pc16.cyan(`\u{1F4E6} \u6B63\u5728\u8C03\u7528\u7CFB\u7EDF unrar \u63D0\u53D6 RAR \u538B\u7F29\u5305...`));
+    console.log(pc17.cyan(`\u{1F4E6} \u6B63\u5728\u8C03\u7528\u7CFB\u7EDF unrar \u63D0\u53D6 RAR \u538B\u7F29\u5305...`));
     const status = await spawnCommand("unrar", ["x", "-y", src, dest]);
     if (!status.success) {
       throw new Error(`unrar \u6267\u884C\u5931\u8D25\uFF0C\u8FDB\u7A0B\u9000\u51FA\u7801: ${status.code}`);
@@ -2409,7 +2081,7 @@ async function uncompressRar(src, dest) {
   }
   const hasRar = isCommandAvailable("rar");
   if (hasRar) {
-    console.log(pc16.cyan(`\u{1F4E6} \u6B63\u5728\u8C03\u7528\u7CFB\u7EDF rar \u63D0\u53D6 RAR \u538B\u7F29\u5305...`));
+    console.log(pc17.cyan(`\u{1F4E6} \u6B63\u5728\u8C03\u7528\u7CFB\u7EDF rar \u63D0\u53D6 RAR \u538B\u7F29\u5305...`));
     const status = await spawnCommand("rar", ["x", "-y", src, dest]);
     if (!status.success) {
       throw new Error(`rar \u6267\u884C\u5931\u8D25\uFF0C\u8FDB\u7A0B\u9000\u51FA\u7801: ${status.code}`);
@@ -2430,20 +2102,20 @@ function registerUnzipCommand(program2) {
         "\u8BF7\u8F93\u5165\u8981\u89E3\u538B\u7684\u538B\u7F29\u5305\u6587\u4EF6\u8DEF\u5F84 (Enter compressed file path):"
       );
       if (!input) {
-        console.error(pc16.red("\u274C \u9519\u8BEF: \u672A\u6307\u5B9A\u6709\u6548\u7684\u538B\u7F29\u5305\u6587\u4EF6\u3002"));
+        console.error(pc17.red("\u274C \u9519\u8BEF: \u672A\u6307\u5B9A\u6709\u6548\u7684\u538B\u7F29\u5305\u6587\u4EF6\u3002"));
         return;
       }
       srcFile = input.trim();
     }
-    const absSrcFile = resolve12(srcFile);
+    const absSrcFile = resolve11(srcFile);
     try {
       const stat = await fs13.stat(absSrcFile);
       if (!stat.isFile()) {
-        console.error(pc16.red(`\u274C \u9519\u8BEF: '${srcFile}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u6587\u4EF6\u3002`));
+        console.error(pc17.red(`\u274C \u9519\u8BEF: '${srcFile}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u6587\u4EF6\u3002`));
         return;
       }
     } catch {
-      console.error(pc16.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u6587\u4EF6 '${srcFile}'\u3002`));
+      console.error(pc17.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u6587\u4EF6 '${srcFile}'\u3002`));
       return;
     }
     const lowerSrc = absSrcFile.toLowerCase();
@@ -2453,17 +2125,17 @@ function registerUnzipCommand(program2) {
     } else if (lowerSrc.endsWith(".tgz")) {
       folderName = basename6(absSrcFile, ".tgz");
     } else {
-      folderName = basename6(absSrcFile, extname(absSrcFile));
+      folderName = basename6(absSrcFile, extname2(absSrcFile));
     }
     let destDir = options.dir;
     if (!destDir) {
       destDir = join8(process.cwd(), folderName);
     } else {
-      destDir = resolve12(process.cwd(), destDir);
+      destDir = resolve11(process.cwd(), destDir);
     }
     try {
-      console.log(pc16.cyan(`\u{1F4E6} \u6B63\u5728\u51C6\u5907\u89E3\u538B: ${absSrcFile}...`));
-      console.log(pc16.cyan(`\u{1F4E5} \u76EE\u6807\u8F93\u51FA\u76EE\u5F55: ${destDir}`));
+      console.log(pc17.cyan(`\u{1F4E6} \u6B63\u5728\u51C6\u5907\u89E3\u538B: ${absSrcFile}...`));
+      console.log(pc17.cyan(`\u{1F4E5} \u76EE\u6807\u8F93\u51FA\u76EE\u5F55: ${destDir}`));
       await fs13.mkdir(destDir, { recursive: true });
       if (lowerSrc.endsWith(".tar.gz") || lowerSrc.endsWith(".tgz")) {
         await uncompressTgz(absSrcFile, destDir);
@@ -2475,16 +2147,16 @@ function registerUnzipCommand(program2) {
         await uncompressRar(absSrcFile, destDir);
       } else {
         console.log(
-          pc16.yellow(
+          pc17.yellow(
             "\u26A0\uFE0F \u672A\u80FD\u8BC6\u522B\u7684\u538B\u7F29\u5305\u683C\u5F0F\u540E\u7F00\u3002\u5C06\u9ED8\u8BA4\u5C1D\u8BD5\u4F5C\u4E3A\u6807\u51C6 ZIP \u8FDB\u884C\u63D0\u53D6..."
           )
         );
         await uncompressZip(absSrcFile, destDir);
       }
-      console.log(pc16.green(`\u2728 \u63D0\u53D6\u6210\u529F\uFF01\u5DF2\u4FDD\u5B58\u5230: ${destDir}`));
+      console.log(pc17.green(`\u2728 \u63D0\u53D6\u6210\u529F\uFF01\u5DF2\u4FDD\u5B58\u5230: ${destDir}`));
     } catch (error) {
       console.error(
-        pc16.red("\u274C \u63D0\u53D6\u5931\u8D25:"),
+        pc17.red("\u274C \u63D0\u53D6\u5931\u8D25:"),
         error instanceof Error ? error.message : error
       );
     }
@@ -2492,7 +2164,7 @@ function registerUnzipCommand(program2) {
 }
 
 // commands/upgrade.ts
-import pc17 from "picocolors";
+import pc18 from "picocolors";
 function registerUpgradeCommand(program2) {
   program2.command("upgrade").description("\u68C0\u67E5\u5E76\u81EA\u52A8\u66F4\u65B0 xx \u547D\u4EE4\u884C\u5DE5\u5177\u81F3\u6700\u65B0\u7248\u672C").option("-r, --registry", "\u5F3A\u5236\u4F7F\u7528 npm \u5B98\u65B9\u6E90 https://registry.npmjs.org/").action(async (options) => {
     const args = ["install", "-g"];
@@ -2500,33 +2172,33 @@ function registerUpgradeCommand(program2) {
       args.push("--registry=https://registry.npmjs.org/");
     }
     args.push("@xx-in/tools@latest");
-    console.log(pc17.cyan("\u{1F916} \u6B63\u5728\u4E3A\u60A8\u68C0\u67E5\u5E76\u66F4\u65B0 xx \u547D\u4EE4\u884C\u5DE5\u5177..."));
-    console.log(pc17.dim(`\u6267\u884C\u547D\u4EE4: npm ${args.join(" ")}
+    console.log(pc18.cyan("\u{1F916} \u6B63\u5728\u4E3A\u60A8\u68C0\u67E5\u5E76\u66F4\u65B0 xx \u547D\u4EE4\u884C\u5DE5\u5177..."));
+    console.log(pc18.dim(`\u6267\u884C\u547D\u4EE4: npm ${args.join(" ")}
 `));
     try {
       const status = await spawnCommand("npm", args);
       if (status.success) {
         console.log(
-          pc17.cyan("\n\u{1F916} \u6B63\u5728\u4E3A\u60A8\u5F3A\u5236\u8986\u76D6\u5E76\u5237\u65B0\u7EC8\u7AEF\u81EA\u52A8\u8865\u5168\u811A\u672C...")
+          pc18.cyan("\n\u{1F916} \u6B63\u5728\u4E3A\u60A8\u5F3A\u5236\u8986\u76D6\u5E76\u5237\u65B0\u7EC8\u7AEF\u81EA\u52A8\u8865\u5168\u811A\u672C...")
         );
         await autoInstallCompletion();
         console.log(
-          pc17.green("\n\u2728 xx \u81EA\u52A8\u66F4\u65B0\u5E76\u91CD\u5237\u8865\u5168\u6210\u529F\uFF01\u5DF2\u6210\u529F\u52A0\u8F7D\u6700\u65B0\u7248\u672C\u3002")
+          pc18.green("\n\u2728 xx \u81EA\u52A8\u66F4\u65B0\u5E76\u91CD\u5237\u8865\u5168\u6210\u529F\uFF01\u5DF2\u6210\u529F\u52A0\u8F7D\u6700\u65B0\u7248\u672C\u3002")
         );
       } else {
         console.error(
-          pc17.red(`
+          pc18.red(`
 \u274C \u66F4\u65B0\u5931\u8D25\uFF0C\u9000\u51FA\u4EE3\u7801 (Exit Code): ${status.code}`)
         );
       }
     } catch (err) {
       console.error(
-        pc17.red(
+        pc18.red(
           "\n\u274C \u65E0\u6CD5\u6267\u884C\u66F4\u65B0\u547D\u4EE4\uFF0C\u8BF7\u786E\u8BA4\u7CFB\u7EDF\u73AF\u5883\u53D8\u91CF\u4E2D\u662F\u5426\u5DF2\u6B63\u786E\u914D\u7F6E Node.js \u4E0E npm\u3002"
         )
       );
       if (err instanceof Error) {
-        console.error(pc17.red("\u9519\u8BEF\u8BE6\u60C5:"), err.message);
+        console.error(pc18.red("\u9519\u8BEF\u8BE6\u60C5:"), err.message);
       }
     }
   });
@@ -2535,8 +2207,8 @@ function registerUpgradeCommand(program2) {
 // commands/zip.ts
 import fs14 from "fs/promises";
 import os2 from "os";
-import pc18 from "picocolors";
-import { join as join9, basename as basename7, relative as relative2, resolve as resolve13 } from "path";
+import pc19 from "picocolors";
+import { join as join9, basename as basename7, relative as relative2, resolve as resolve12 } from "path";
 var IGNORE_FILE_NAME = ".cpzipignore";
 var DEFAULT_BLACKLIST = [
   "# cpzip \u5FFD\u7565\u914D\u7F6E\u6587\u4EF6",
@@ -2555,20 +2227,20 @@ async function getBlacklist(absSrcDir) {
   const cwdIgnorePath = join9(process.cwd(), IGNORE_FILE_NAME);
   try {
     const content = await fs14.readFile(targetIgnorePath, "utf-8");
-    console.log(pc18.cyan(`[zip] \u627E\u5230\u76EE\u6807\u76EE\u5F55\u4E0B\u7684\u5FFD\u7565\u6587\u4EF6: ${targetIgnorePath}`));
+    console.log(pc19.cyan(`[zip] \u627E\u5230\u76EE\u6807\u76EE\u5F55\u4E0B\u7684\u5FFD\u7565\u6587\u4EF6: ${targetIgnorePath}`));
     return parseIgnoreContent(content);
   } catch {
   }
   try {
     const content = await fs14.readFile(cwdIgnorePath, "utf-8");
-    console.log(pc18.cyan(`[zip] \u627E\u5230\u5F53\u524D\u76EE\u5F55\u4E0B\u7684\u5FFD\u7565\u6587\u4EF6: ${cwdIgnorePath}`));
+    console.log(pc19.cyan(`[zip] \u627E\u5230\u5F53\u524D\u76EE\u5F55\u4E0B\u7684\u5FFD\u7565\u6587\u4EF6: ${cwdIgnorePath}`));
     return parseIgnoreContent(content);
   } catch (err) {
     if (isNotFoundError(err)) {
-      console.log(pc18.dim(`[zip] \u672A\u627E\u5230\u5FFD\u7565\u6587\u4EF6\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u8FC7\u6EE4\u89C4\u5219\u3002`));
+      console.log(pc19.dim(`[zip] \u672A\u627E\u5230\u5FFD\u7565\u6587\u4EF6\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u8FC7\u6EE4\u89C4\u5219\u3002`));
       return parseIgnoreContent(DEFAULT_BLACKLIST.join("\n"));
     }
-    console.error(pc18.red(`[zip] \u8BFB\u53D6\u5FFD\u7565\u6587\u4EF6\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u89C4\u5219\u3002`), err);
+    console.error(pc19.red(`[zip] \u8BFB\u53D6\u5FFD\u7565\u6587\u4EF6\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u89C4\u5219\u3002`), err);
     return parseIgnoreContent(DEFAULT_BLACKLIST.join("\n"));
   }
 }
@@ -2617,20 +2289,20 @@ function registerZipCommand(program2) {
     if (!srcDir) {
       const input = prompt("\u8BF7\u8F93\u5165\u8981\u6253\u5305\u7684\u76EE\u5F55\u8DEF\u5F84 (Enter directory path):");
       if (!input) {
-        console.error(pc18.red("\u274C \u9519\u8BEF: \u672A\u6307\u5B9A\u6709\u6548\u7684\u8F93\u5165\u76EE\u5F55\u3002"));
+        console.error(pc19.red("\u274C \u9519\u8BEF: \u672A\u6307\u5B9A\u6709\u6548\u7684\u8F93\u5165\u76EE\u5F55\u3002"));
         return;
       }
       srcDir = input.trim();
     }
-    const absSrcDir = resolve13(srcDir);
+    const absSrcDir = resolve12(srcDir);
     try {
       const stat = await fs14.stat(absSrcDir);
       if (!stat.isDirectory()) {
-        console.error(pc18.red(`\u274C \u9519\u8BEF: '${srcDir}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
+        console.error(pc19.red(`\u274C \u9519\u8BEF: '${srcDir}' \u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684\u76EE\u5F55\u3002`));
         return;
       }
     } catch {
-      console.error(pc18.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u76EE\u5F55 '${srcDir}'\u3002`));
+      console.error(pc19.red(`\u274C \u9519\u8BEF: \u627E\u4E0D\u5230\u76EE\u5F55 '${srcDir}'\u3002`));
       return;
     }
     const dirName = basename7(absSrcDir);
@@ -2639,13 +2311,13 @@ function registerZipCommand(program2) {
     const tempDir = await fs14.mkdtemp(join9(os2.tmpdir(), "cpzip_temp_"));
     const tempCopyTarget = join9(tempDir, dirName);
     try {
-      console.log(pc18.cyan(`\u{1F4E6} \u6B63\u5728\u590D\u5236\u76EE\u5F55\u5E76\u8FC7\u6EE4\u5FFD\u7565\u9879...`));
+      console.log(pc19.cyan(`\u{1F4E6} \u6B63\u5728\u590D\u5236\u76EE\u5F55\u5E76\u8FC7\u6EE4\u5FFD\u7565\u9879...`));
       await copyRecursive3(absSrcDir, tempCopyTarget, absSrcDir, blacklist);
-      console.log(pc18.cyan(`\u26A1 \u6B63\u5728\u6253\u5305\u4E3A ZIP \u538B\u7F29\u5305...`));
+      console.log(pc19.cyan(`\u26A1 \u6B63\u5728\u6253\u5305\u4E3A ZIP \u538B\u7F29\u5305...`));
       await compressZip(tempCopyTarget, outputZip);
-      console.log(pc18.green(`\u2728 \u6253\u5305\u6210\u529F\uFF01\u538B\u7F29\u5305\u4FDD\u5B58\u4E3A: ${outputZip}`));
+      console.log(pc19.green(`\u2728 \u6253\u5305\u6210\u529F\uFF01\u538B\u7F29\u5305\u4FDD\u5B58\u4E3A: ${outputZip}`));
     } catch (error) {
-      console.error(pc18.red("\u274C \u6253\u5305\u5931\u8D25:"), error);
+      console.error(pc19.red("\u274C \u6253\u5305\u5931\u8D25:"), error);
     } finally {
       try {
         await fs14.rm(tempDir, { recursive: true });