@ruan-cat/vercel-deploy-tool 0.12.2 → 1.1.0

package/dist/cli.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path from "path";
+import { Command as Command3 } from "commander";
+
+// src/commands/deploy.ts
+import { Command } from "commander";
+import { consola as consola10 } from "consola";
+import { config as dotenvxConfig2 } from "@dotenvx/dotenvx";
+
+// src/config/loader.ts
+import { loadConfig as c12LoadConfig } from "c12";
+import { consola } from "consola";
+import { isUndefined } from "lodash-es";
+import { config as dotenvxConfig } from "@dotenvx/dotenvx";
+import { printFormat } from "@ruan-cat/utils";
+var CONFIG_NAME = "vercel-deploy-tool";
+var DEFAULT_CONFIG = {
+  vercelProjectName: "",
+  vercelToken: "",
+  vercelOrgId: "",
+  vercelProjectId: "",
+  deployTargets: []
+};
+async function loadConfig() {
+  consola.start("\u5F00\u59CB\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 vercel-deploy-tool.config.* ...");
+  const envPath = process.env.VERCEL_DEPLOY_TOOL_ENV_PATH;
+  if (envPath) {
+    dotenvxConfig({ path: envPath });
+    consola.info(`\u5DF2\u4ECE VERCEL_DEPLOY_TOOL_ENV_PATH \u52A0\u8F7D dotenv: ${envPath}`);
+  }
+  let config;
+  const loaded = await c12LoadConfig({
+    cwd: process.cwd(),
+    name: CONFIG_NAME,
+    dotenv: true,
+    defaults: DEFAULT_CONFIG
+  });
+  config = loaded.config;
+  const vercelOrgId = process.env.VERCEL_ORG_ID;
+  const vercelProjectId = process.env.VERCEL_PROJECT_ID;
+  const vercelToken = process.env.VERCEL_TOKEN;
+  if (!isUndefined(vercelOrgId)) {
+    config.vercelOrgId = vercelOrgId;
+  }
+  if (!isUndefined(vercelProjectId)) {
+    config.vercelProjectId = vercelProjectId;
+  }
+  if (!isUndefined(vercelToken)) {
+    config.vercelToken = vercelToken;
+  }
+  consola.success("\u914D\u7F6E\u52A0\u8F7D\u5B8C\u6210");
+  consola.box(printFormat(config));
+  return config;
+}
+
+// src/core/tasks/index.ts
+import fs4 from "fs";
+import { resolve as resolve5 } from "path";
+import { consola as consola9 } from "consola";
+
+// src/core/executor.ts
+import task from "tasuku";
+async function executeSequential(title, tasks) {
+  const results = [];
+  for (const t of tasks) {
+    const result = await task(t.name, t.fn);
+    results.push(result.result);
+  }
+  return results;
+}
+
+// src/utils/type-guards.ts
+function isDeployTargetWithUserCommands(target) {
+  return target.type === "userCommands";
+}
+function getIsCopyDist(target) {
+  return target.isCopyDist ?? true;
+}
+function isNeedVercelBuild(target) {
+  return target.isNeedVercelBuild ?? true;
+}
+
+// src/utils/vercel-null-config.ts
+var VERCEL_NULL_CONFIG = {
+  framework: null,
+  buildCommand: null,
+  installCommand: null,
+  outputDirectory: null,
+  devCommand: null,
+  public: false,
+  /**
+   * 部署后提供干净的链接
+   * @see https://vercel.com/docs/projects/project-configuration#cleanurls
+   *
+   * @description
+   * 暂无效果
+   *
+   * 目前在 build-output-api 中，实现cleanUrls需要手动地写入配置文件
+   *
+   * 成本较大，目前不做投入。
+   */
+  cleanUrls: true,
+  git: {
+    deploymentEnabled: {
+      main: false
+    }
+  }
+};
+var VERCEL_NULL_CONFIG_PATH = "./vercel.null.def.json";
+var VERCEL_OUTPUT_STATIC = ".vercel/output/static";
+
+// src/core/tasks/link.ts
+import fs from "fs";
+import { resolve } from "path";
+import { spawnSync } from "child_process";
+import { concat } from "lodash-es";
+import { consola as consola2 } from "consola";
+
+// src/core/vercel.ts
+function getVercelProjectNameArg(config) {
+  return ["--project", config.vercelProjectName];
+}
+function getVercelScopeArg(config) {
+  return ["--scope", config.vercelOrgId];
+}
+function getVercelTokenArg(config) {
+  return ["--token", config.vercelToken];
+}
+function getVercelLocalConfigArg() {
+  return ["--local-config", VERCEL_NULL_CONFIG_PATH];
+}
+function getTargetCWDArg(target) {
+  return ["--cwd", target.targetCWD];
+}
+function createVercelSpawnOptions(stdoutMode = "inherit") {
+  const base = {
+    encoding: "utf8",
+    shell: process.platform === "win32"
+  };
+  if (stdoutMode === "pipe") {
+    return { ...base, stdio: ["inherit", "pipe", "inherit"] };
+  }
+  return { ...base, stdio: "inherit" };
+}
+
+// src/core/tasks/link.ts
+function createLinkTask(config, target) {
+  return {
+    name: `Link: ${target.targetCWD}`,
+    fn: async () => {
+      const targetPath = resolve(target.targetCWD);
+      if (!fs.existsSync(targetPath)) {
+        const err = new Error(`\u76EE\u6807\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6784\u5EFA: ${target.targetCWD}`);
+        consola2.error(err.message);
+        throw err;
+      }
+      const args = concat(
+        ["link"],
+        ["--yes"],
+        getTargetCWDArg(target),
+        getVercelProjectNameArg(config),
+        getVercelTokenArg(config)
+      );
+      consola2.start(`\u5F00\u59CB link \u4EFB\u52A1: ${target.targetCWD}`);
+      const result = spawnSync("vercel", args, createVercelSpawnOptions());
+      if (result.error) {
+        consola2.error(`link \u4EFB\u52A1\u5931\u8D25: ${target.targetCWD}`);
+        throw result.error;
+      }
+      consola2.success(`\u5B8C\u6210 link \u4EFB\u52A1: ${target.targetCWD}`);
+      return result.stdout;
+    }
+  };
+}
+
+// src/core/tasks/build.ts
+import fs2 from "fs";
+import { resolve as resolve2 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { concat as concat2 } from "lodash-es";
+import { consola as consola3 } from "consola";
+function createBuildTask(config, target) {
+  return {
+    name: `Build: ${target.targetCWD}`,
+    fn: async () => {
+      const targetPath = resolve2(target.targetCWD);
+      if (!fs2.existsSync(targetPath)) {
+        const err = new Error(`\u76EE\u6807\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6784\u5EFA: ${target.targetCWD}`);
+        consola3.error(err.message);
+        throw err;
+      }
+      const args = concat2(
+        ["build"],
+        ["--yes"],
+        ["--prod"],
+        getTargetCWDArg(target),
+        getVercelLocalConfigArg(),
+        getVercelTokenArg(config)
+      );
+      consola3.start(`\u5F00\u59CB build \u4EFB\u52A1: ${target.targetCWD}`);
+      const result = spawnSync2("vercel", args, createVercelSpawnOptions());
+      if (result.error) {
+        consola3.error(`build \u4EFB\u52A1\u5931\u8D25: ${target.targetCWD}`);
+        throw result.error;
+      }
+      consola3.success(`\u5B8C\u6210 build \u4EFB\u52A1: ${target.targetCWD}`);
+      return result.stdout;
+    }
+  };
+}
+
+// src/core/tasks/after-build.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { consola as consola4 } from "consola";
+import { isUndefined as isUndefined2, isEmpty } from "lodash-es";
+function createAfterBuildTasks(config) {
+  const afterBuildTasks = config.afterBuildTasks;
+  if (isUndefined2(afterBuildTasks) || isEmpty(afterBuildTasks)) {
+    return [
+      {
+        name: "AfterBuild: \u65E0\u4EFB\u52A1",
+        fn: async () => {
+          consola4.warn("\u5F53\u524D\u6CA1\u6709\u6709\u610F\u4E49\u7684 afterBuildTasks \u4EFB\u52A1\u914D\u7F6E");
+          return void 0;
+        }
+      }
+    ];
+  }
+  return afterBuildTasks.map((command) => ({
+    name: `AfterBuild: ${command}`,
+    fn: async () => {
+      consola4.start(`\u5F00\u59CB afterBuild \u4EFB\u52A1: ${command}`);
+      const result = spawnSync3(command, [], {
+        encoding: "utf-8",
+        stdio: "inherit",
+        shell: true
+      });
+      if (result.error) {
+        consola4.error(`afterBuild \u4EFB\u52A1\u5931\u8D25: ${command}`);
+        throw result.error;
+      }
+      consola4.success(`\u5B8C\u6210 afterBuild \u4EFB\u52A1: ${command}`);
+      return result.stdout;
+    }
+  }));
+}
+
+// src/core/tasks/user-commands.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import { consola as consola5 } from "consola";
+function createUserCommandTasks(target) {
+  return target.userCommands.map((command) => ({
+    name: `UserCommand: ${command}`,
+    fn: async () => {
+      consola5.start(`\u5F00\u59CB\u7528\u6237\u547D\u4EE4\u4EFB\u52A1: ${command}`);
+      const result = spawnSync4(command, [], {
+        encoding: "utf-8",
+        stdio: "inherit",
+        shell: true
+      });
+      if (result.error) {
+        consola5.error(`\u7528\u6237\u547D\u4EE4\u4EFB\u52A1\u5931\u8D25: ${command}`);
+        throw result.error;
+      }
+      consola5.success(`\u5B8C\u6210\u7528\u6237\u547D\u4EE4\u4EFB\u52A1: ${command}`);
+      return result.stdout;
+    }
+  }));
+}
+
+// src/core/tasks/copy-dist.ts
+import { resolve as resolve3 } from "path";
+import { rmSync, mkdirSync, cpSync } from "fs";
+import { consola as consola6 } from "consola";
+function createCopyDistTasks(target) {
+  const targetCWD = target.targetCWD;
+  const outputDirectory = target.outputDirectory;
+  function joinPath(dir) {
+    return resolve3(process.cwd(), targetCWD, dir);
+  }
+  const pathVercelOutputStatic = joinPath(VERCEL_OUTPUT_STATIC);
+  const pathOutputDirectory = joinPath(outputDirectory);
+  return [
+    {
+      name: `\u5220\u9664\u76EE\u5F55: ${pathVercelOutputStatic}`,
+      fn: async () => {
+        consola6.start(`\u5F00\u59CB\u5220\u9664\u6587\u4EF6\u4EFB\u52A1: ${pathVercelOutputStatic}`);
+        rmSync(pathVercelOutputStatic, { recursive: true, force: true });
+        consola6.success(`\u5220\u9664\u8BE5\u8DEF\u5F84\u7684\u6587\u4EF6: ${pathVercelOutputStatic}`);
+      }
+    },
+    {
+      name: `\u521B\u5EFA\u76EE\u5F55: ${pathVercelOutputStatic}`,
+      fn: async () => {
+        consola6.start(`\u5F00\u59CB\u521B\u5EFA\u6587\u4EF6\u5939\u4EFB\u52A1: ${pathVercelOutputStatic}`);
+        mkdirSync(pathVercelOutputStatic, { recursive: true });
+        consola6.success(`\u521B\u5EFA\u7684\u65B0\u76EE\u5F55\u4E3A: ${pathVercelOutputStatic}`);
+      }
+    },
+    {
+      name: `\u590D\u5236\u6587\u4EF6: ${pathOutputDirectory} -> ${pathVercelOutputStatic}`,
+      fn: async () => {
+        consola6.start(`\u5F00\u59CB\u6587\u4EF6\u590D\u5236\u4EFB\u52A1`);
+        consola6.info(`\u4ECE ${pathOutputDirectory} \u5F00\u59CB`);
+        consola6.info(`\u590D\u5236\u5230 ${pathVercelOutputStatic} \u5185`);
+        cpSync(pathOutputDirectory, pathVercelOutputStatic, { recursive: true });
+        consola6.success(`\u5B8C\u6210\u6587\u4EF6\u590D\u5236\u4EFB\u52A1`);
+      }
+    }
+  ];
+}
+
+// src/core/tasks/deploy.ts
+import fs3 from "fs";
+import { resolve as resolve4 } from "path";
+import { spawnSync as spawnSync5 } from "child_process";
+import { concat as concat3 } from "lodash-es";
+import { consola as consola7 } from "consola";
+function createDeployTask(config, target) {
+  return {
+    name: `Deploy: ${target.targetCWD}`,
+    fn: async () => {
+      const targetPath = resolve4(target.targetCWD);
+      if (!fs3.existsSync(targetPath)) {
+        const err = new Error(`\u76EE\u6807\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6784\u5EFA: ${target.targetCWD}`);
+        consola7.error(err.message);
+        throw err;
+      }
+      const args = concat3(
+        ["deploy"],
+        ["--yes"],
+        ["--prebuilt"],
+        ["--prod"],
+        getTargetCWDArg(target),
+        getVercelTokenArg(config)
+      );
+      consola7.start(`\u5F00\u59CB\u90E8\u7F72\u4EFB\u52A1: ${target.targetCWD}`);
+      const result = spawnSync5("vercel", args, createVercelSpawnOptions("pipe"));
+      if (result.error) {
+        consola7.error(`\u90E8\u7F72\u5931\u8D25\u4E86: ${target.targetCWD}`);
+        consola7.error(result.error);
+        throw result.error;
+      }
+      const vercelUrl = result.stdout.toString().trim();
+      consola7.success(`\u5B8C\u6210\u90E8\u7F72\u4EFB\u52A1\uFF0C\u751F\u6210\u7684url\u4E3A:`);
+      consola7.box(vercelUrl);
+      return vercelUrl;
+    }
+  };
+}
+
+// src/core/tasks/alias.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import { concat as concat4 } from "lodash-es";
+import { consola as consola8 } from "consola";
+function createAliasTask(config, vercelUrl, userUrl) {
+  return {
+    name: `Alias: ${userUrl}`,
+    fn: async () => {
+      const args = concat4(["alias", "set", vercelUrl, userUrl], getVercelTokenArg(config), getVercelScopeArg(config));
+      consola8.start(`\u5F00\u59CB\u522B\u540D\u4EFB\u52A1: ${userUrl}`);
+      const result = spawnSync6("vercel", args, createVercelSpawnOptions());
+      if (result.error) {
+        consola8.error(`\u522B\u540D\u4EFB\u52A1\u5931\u8D25: ${userUrl}`);
+        throw result.error;
+      }
+      consola8.success(`\u5B8C\u6210\u522B\u540D\u4EFB\u52A1\uFF0C\u53EF\u7528\u7684\u522B\u540D\u5730\u5740\u4E3A:`);
+      consola8.box(`https://${userUrl}`);
+      return result.stdout;
+    }
+  };
+}
+
+// src/core/tasks/index.ts
+async function generateVercelNullConfig() {
+  fs4.writeFileSync(VERCEL_NULL_CONFIG_PATH, JSON.stringify(VERCEL_NULL_CONFIG, null, 2));
+  consola9.success(`\u751F\u6210 Vercel \u7A7A\u914D\u7F6E\u6587\u4EF6: ${VERCEL_NULL_CONFIG_PATH}`);
+}
+async function executeDeploymentWorkflow(config) {
+  await generateVercelNullConfig();
+  const { deployTargets } = config;
+  const availableTargets = deployTargets.filter((target) => {
+    const targetPath = resolve5(target.targetCWD);
+    if (!fs4.existsSync(targetPath)) {
+      consola9.warn(`\u76EE\u6807\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7: ${target.targetCWD}`);
+      return false;
+    }
+    return true;
+  });
+  if (availableTargets.length === 0) {
+    consola9.error("\u6CA1\u6709\u53EF\u7528\u7684\u90E8\u7F72\u76EE\u6807\uFF0C\u8BF7\u5148\u6784\u5EFA\u4EA7\u7269");
+    return;
+  }
+  await task("Vercel \u90E8\u7F72\u5DE5\u4F5C\u6D41", async ({ task: task2 }) => {
+    await task2("1. Link \u9879\u76EE", async () => {
+      const linkTasks = availableTargets.map((target) => createLinkTask(config, target));
+      await task2.group((task3) => linkTasks.map((t) => task3(t.name, t.fn)));
+    });
+    await task2("2. \u6784\u5EFA\u9879\u76EE", async () => {
+      const buildTasks = availableTargets.filter(isNeedVercelBuild).map((target) => createBuildTask(config, target));
+      if (buildTasks.length === 0) {
+        consola9.warn("\u6CA1\u6709\u9700\u8981\u6267\u884C build \u7684\u76EE\u6807");
+        return;
+      }
+      await task2.group((task3) => buildTasks.map((t) => task3(t.name, t.fn)));
+    });
+    await task2("3. \u6267\u884C AfterBuild \u4EFB\u52A1", async () => {
+      const afterBuildTasks = createAfterBuildTasks(config);
+      await executeSequential("AfterBuild", afterBuildTasks);
+    });
+    await task2("4. \u6267\u884C\u7528\u6237\u547D\u4EE4\u4E0E\u6587\u4EF6\u590D\u5236", async () => {
+      const targetTasks = availableTargets.map((target) => ({
+        name: `\u5904\u7406\u76EE\u6807: ${target.targetCWD}`,
+        fn: async () => {
+          if (!isDeployTargetWithUserCommands(target)) {
+            consola9.warn(`\u76EE\u6807 ${target.targetCWD} \u4E0D\u5C5E\u4E8E userCommands \u7C7B\u578B`);
+            return;
+          }
+          const userCommandTasks = createUserCommandTasks(target);
+          await executeSequential(`UserCommands: ${target.targetCWD}`, userCommandTasks);
+          if (getIsCopyDist(target)) {
+            const copyDistTasks = createCopyDistTasks(target);
+            await executeSequential(`CopyDist: ${target.targetCWD}`, copyDistTasks);
+          } else {
+            consola9.warn(`\u76EE\u6807 ${target.targetCWD} \u4E0D\u9700\u8981\u590D\u5236\u6587\u4EF6`);
+          }
+        }
+      }));
+      await task2.group((task3) => targetTasks.map((t) => task3(t.name, t.fn)));
+    });
+    await task2("5. \u90E8\u7F72\u4E0E\u8BBE\u7F6E\u522B\u540D", async () => {
+      const deployAliasTasks = availableTargets.map((target) => ({
+        name: `\u90E8\u7F72\u4E0E\u522B\u540D: ${target.targetCWD}`,
+        fn: async () => {
+          const deployTask = createDeployTask(config, target);
+          const deployResult = await task2(deployTask.name, deployTask.fn);
+          const vercelUrl = deployResult.result;
+          if (target.url && target.url.length > 0) {
+            const aliasTasks = target.url.map((userUrl) => createAliasTask(config, vercelUrl, userUrl));
+            await task2.group((task3) => aliasTasks.map((t) => task3(t.name, t.fn)));
+          } else {
+            consola9.warn(`\u76EE\u6807 ${target.targetCWD} \u6CA1\u6709\u914D\u7F6E\u522B\u540D`);
+          }
+        }
+      }));
+      await task2.group((task3) => deployAliasTasks.map((t) => task3(t.name, t.fn)));
+    });
+  });
+  consola9.success("\u{1F389} Vercel \u90E8\u7F72\u5DE5\u4F5C\u6D41\u5B8C\u6210\uFF01");
+}
+
+// src/commands/deploy.ts
+function createDeployCommand() {
+  const command = new Command("deploy");
+  command.description("\u90E8\u7F72\u9879\u76EE\u5230 Vercel").option("--env-path <path>", "\u6307\u5B9A dotenv \u6587\u4EF6\u8DEF\u5F84\uFF0C\u7528\u4E8E\u8986\u76D6\u9ED8\u8BA4\u73AF\u5883\u53D8\u91CF").action(async (options) => {
+    try {
+      if (options?.envPath) {
+        process.env.VERCEL_DEPLOY_TOOL_ENV_PATH = options.envPath;
+        dotenvxConfig2({ path: options.envPath });
+        consola10.info(`\u5DF2\u4ECE --env-path \u52A0\u8F7D\u73AF\u5883\u53D8\u91CF: ${options.envPath}`);
+      }
+      consola10.start("\u5F00\u59CB\u52A0\u8F7D\u914D\u7F6E...");
+      const config = await loadConfig();
+      consola10.start("\u5F00\u59CB\u6267\u884C\u90E8\u7F72\u5DE5\u4F5C\u6D41...");
+      await executeDeploymentWorkflow(config);
+      consola10.success("\u90E8\u7F72\u5B8C\u6210\uFF01");
+    } catch (error) {
+      consola10.error("\u90E8\u7F72\u5931\u8D25:");
+      consola10.error(error);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/init.ts
+import { Command as Command2 } from "commander";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { consola as consola11 } from "consola";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function createInitCommand() {
+  const command = new Command2("init");
+  command.description("\u521D\u59CB\u5316\u914D\u7F6E\u6587\u4EF6").option("-f, --force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u6587\u4EF6").action((options) => {
+    const cwd = process.cwd();
+    const configFile = "vercel-deploy-tool.config.ts";
+    const targetPath = join(cwd, configFile);
+    if (existsSync(targetPath) && !options.force) {
+      consola11.warn(`\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728: ${configFile}`);
+      consola11.info("\u4F7F\u7528 --force \u9009\u9879\u53EF\u4EE5\u8986\u76D6");
+      return;
+    }
+    const templatePath = join(__dirname2, "..", "templates", configFile);
+    if (!existsSync(templatePath)) {
+      consola11.error(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${templatePath}`);
+      consola11.error("\u8BF7\u786E\u4FDD @ruan-cat/vercel-deploy-tool \u5305\u5DF2\u6B63\u786E\u5B89\u88C5");
+      process.exit(1);
+    }
+    const content = readFileSync(templatePath, "utf-8");
+    writeFileSync(targetPath, content, "utf-8");
+    consola11.success(`\u5DF2\u521B\u5EFA\u914D\u7F6E\u6587\u4EF6: ${configFile}`);
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (!pkg.scripts) pkg.scripts = {};
+        pkg.scripts["deploy-vercel"] = "vercel-deploy-tool deploy";
+        writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+        consola11.success('\u5DF2\u6DFB\u52A0\u811A\u672C: "deploy-vercel"');
+      } catch (error) {
+        consola11.warn("\u66F4\u65B0 package.json \u5931\u8D25:", error);
+      }
+    }
+    consola11.box(`\u{1F389} \u521D\u59CB\u5316\u5B8C\u6210\uFF01
+
+\u521B\u5EFA\u7684\u6587\u4EF6:
+  \u2022 ${configFile} - Vercel \u90E8\u7F72\u914D\u7F6E\u6587\u4EF6
+
+\u6DFB\u52A0\u7684\u811A\u672C:
+  \u2022 deploy-vercel: vercel-deploy-tool deploy
+
+\u4E0B\u4E00\u6B65:
+  1. \u7F16\u8F91 ${configFile} \u586B\u5199\u4F60\u7684\u914D\u7F6E
+  2. \u786E\u4FDD\u73AF\u5883\u53D8\u91CF\u5DF2\u8BBE\u7F6E:
+     - VERCEL_TOKEN
+     - VERCEL_ORG_ID
+     - VERCEL_PROJECT_ID
+  3. \u8FD0\u884C\u90E8\u7F72:
+     pnpm run deploy-vercel`);
+  });
+  return command;
+}
+
+// src/cli.ts
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = path.dirname(__filename3);
+var packageJsonPath = path.join(__dirname3, "..", "package.json");
+var packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+var { version } = packageJson;
+var program = new Command3();
+program.name("vercel-deploy-tool").description("Vercel \u90E8\u7F72\u5DE5\u5177 - \u652F\u6301 monorepo \u7684\u81EA\u52A8\u5316\u90E8\u7F72").version(version);
+program.addCommand(createDeployCommand());
+program.addCommand(createInitCommand());
+program.on("--help", () => {
+  console.log("");
+  console.log("\u4F7F\u7528\u793A\u4F8B / Usage Examples:");
+  console.log("");
+  console.log("  # \u521D\u59CB\u5316\u914D\u7F6E\u6587\u4EF6");
+  console.log("  vercel-deploy-tool init");
+  console.log("  vdt init");
+  console.log("");
+  console.log("  # \u90E8\u7F72\u9879\u76EE");
+  console.log("  vercel-deploy-tool deploy");
+  console.log("  vdt deploy");
+  console.log("");
+  console.log("  # \u67E5\u770B\u5E2E\u52A9");
+  console.log("  vercel-deploy-tool --help");
+  console.log("  vdt --help");
+  console.log("");
+  console.log("\u73AF\u5883\u53D8\u91CF / Environment Variables:");
+  console.log("  VERCEL_TOKEN       - Vercel API Token");
+  console.log("  VERCEL_ORG_ID      - Vercel \u7EC4\u7EC7 ID");
+  console.log("  VERCEL_PROJECT_ID  - Vercel \u9879\u76EE ID");
+  console.log("");
+});
+async function main() {
+  await program.parseAsync();
+}
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});