gz-cli-front 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,1472 @@
+// src/index.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+
+// src/commands/create.ts
+import { confirm, input, select } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import { execa as execa2 } from "execa";
+import fs6 from "fs-extra";
+import ora from "ora";
+import path7 from "path";
+import { performance as performance5 } from "perf_hooks";
+
+// src/services/config.ts
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+var CONFIG_FILE_NAME = "gz-cli-front.config.json";
+async function loadCliConfig() {
+  const configPath = await findConfigPath();
+  const config = await fs.readJson(configPath);
+  if (!isCliConfig(config)) {
+    throw new Error(`CLI \u914D\u7F6E\u6587\u4EF6\u65E0\u6548\uFF1A${configPath}`);
+  }
+  return config;
+}
+async function findConfigPath() {
+  const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+  const configPaths = [
+    path.resolve(moduleDirectory, "config", CONFIG_FILE_NAME),
+    path.resolve(moduleDirectory, "..", "config", CONFIG_FILE_NAME),
+    path.resolve(moduleDirectory, "..", "..", "config", CONFIG_FILE_NAME)
+  ];
+  for (const configPath of configPaths) {
+    if (await fs.pathExists(configPath)) {
+      return configPath;
+    }
+  }
+  throw new Error("\u672A\u627E\u5230 gz-cli-front \u914D\u7F6E\u6587\u4EF6\u3002");
+}
+function isCliConfig(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const templateRegistry = value.templateRegistry;
+  if (typeof templateRegistry !== "object" || templateRegistry === null) {
+    return false;
+  }
+  return isTemplateRegistryConfig(templateRegistry);
+}
+function isTemplateRegistryConfig(value) {
+  if (!isNonEmptyString(value.url)) {
+    return false;
+  }
+  if (value.source === void 0 || value.source === "http") {
+    return true;
+  }
+  return value.source === "git" && isNonEmptyString(value.file) && (value.version === void 0 || isNonEmptyString(value.version));
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/utils/pkg-manager.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import { spawnSync } from "child_process";
+var PACKAGE_MANAGERS = ["pnpm", "yarn", "npm"];
+function detectPackageManager() {
+  return PACKAGE_MANAGERS.find(isPackageManagerAvailable) ?? "npm";
+}
+function isPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+async function updateProjectPackageJson(targetDir, projectName, packageManager) {
+  const packageJsonPath = path2.join(targetDir, "package.json");
+  if (!await fs2.pathExists(packageJsonPath)) {
+    return;
+  }
+  const packageJson = await fs2.readJson(packageJsonPath);
+  packageJson.name = projectName;
+  if (Object.prototype.hasOwnProperty.call(packageJson, "packageManager")) {
+    packageJson.packageManager = packageManager;
+  }
+  await fs2.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+function isPackageManagerAvailable(packageManager) {
+  const result = spawnSync(packageManager, ["--version"], {
+    shell: process.platform === "win32",
+    stdio: "ignore"
+  });
+  return result.status === 0;
+}
+
+// src/utils/template.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+import { performance as performance3 } from "perf_hooks";
+
+// src/utils/cache.ts
+import { createHash } from "crypto";
+import os from "os";
+import path3 from "path";
+var TEMPLATE_REGISTRY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var TEMPLATE_ARCHIVE_CACHE_TTL_MS = 10 * 60 * 1e3;
+function getTemplateRegistryCachePath(url) {
+  return path3.join(getCacheDirectory(), "registry", `${createCacheKey(url)}.json`);
+}
+function getTemplateArchiveCachePath(source) {
+  return path3.join(getCacheDirectory(), "templates", `${createCacheKey(source)}.tar.gz`);
+}
+function getGitRepositoryCachePath(namespace, source) {
+  return path3.join(getCacheDirectory(), namespace, `git-${createCacheKey(source)}`);
+}
+function isCacheFresh(updatedAt, ttlMs) {
+  return Date.now() - updatedAt < ttlMs;
+}
+function getCacheDirectory() {
+  const configuredDirectory = process.env.GZ_CLI_FRONT_CACHE_DIR?.trim();
+  return configuredDirectory || path3.join(os.homedir(), ".gz-cli-front", "cache");
+}
+function createCacheKey(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+
+// src/utils/http.ts
+import { setTimeout as delay } from "timers/promises";
+import {
+  EnvHttpProxyAgent,
+  ProxyAgent,
+  fetch as undiciFetch
+} from "undici";
+
+// src/utils/system-proxy.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var WINDOWS_INTERNET_SETTINGS = String.raw`HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings`;
+var SYSTEM_PROXY_TIMEOUT_MS = 1500;
+var systemProxyCache = /* @__PURE__ */ new Map();
+function getSystemProxy(target) {
+  const cacheKey = `${process.platform}:${target.protocol}`;
+  const cached = systemProxyCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const request = detectSystemProxy(target).catch(() => ({}));
+  systemProxyCache.set(cacheKey, request);
+  return request;
+}
+async function detectSystemProxy(target) {
+  if (process.platform === "win32") {
+    return detectWindowsProxy(target);
+  }
+  if (process.platform === "darwin") {
+    return detectMacOsProxy(target);
+  }
+  if (process.platform === "linux") {
+    return detectLinuxProxy(target);
+  }
+  return {};
+}
+async function detectWindowsProxy(target) {
+  const [enabledOutput, serverOutput, overrideOutput] = await Promise.all([
+    queryWindowsRegistry("ProxyEnable"),
+    queryWindowsRegistry("ProxyServer"),
+    queryWindowsRegistry("ProxyOverride")
+  ]);
+  const enabled = readRegistryValue(enabledOutput, "ProxyEnable");
+  if (enabled !== "0x1" && enabled !== "1") {
+    return {};
+  }
+  const proxyServer = readRegistryValue(serverOutput, "ProxyServer");
+  if (!proxyServer) {
+    return {};
+  }
+  const proxyAddress = selectWindowsProxy(proxyServer, target.protocol);
+  if (!proxyAddress) {
+    return {};
+  }
+  const proxyOverride = readRegistryValue(overrideOutput, "ProxyOverride");
+  return {
+    noProxy: proxyOverride?.split(";").filter((entry) => entry !== "<local>").join(","),
+    proxyUrl: normalizeProxyUrl(proxyAddress)
+  };
+}
+async function queryWindowsRegistry(valueName) {
+  try {
+    const result = await execFileAsync(
+      "reg.exe",
+      ["query", WINDOWS_INTERNET_SETTINGS, "/v", valueName],
+      { timeout: SYSTEM_PROXY_TIMEOUT_MS, windowsHide: true }
+    );
+    return result.stdout;
+  } catch {
+    return "";
+  }
+}
+function readRegistryValue(output, valueName) {
+  const line = output.split(/\r?\n/).find((entry) => entry.includes(valueName));
+  return line?.match(/REG_\w+\s+(.+)$/)?.[1]?.trim();
+}
+function selectWindowsProxy(proxyServer, protocol) {
+  if (!proxyServer.includes("=")) {
+    return proxyServer;
+  }
+  const proxies = new Map(
+    proxyServer.split(";").flatMap((entry) => {
+      const [key, value] = entry.split("=", 2).map((part) => part.trim());
+      return key && value ? [[key.toLowerCase(), value]] : [];
+    })
+  );
+  const protocolName = protocol.replace(":", "");
+  return proxies.get(protocolName) ?? proxies.get("http");
+}
+async function detectMacOsProxy(target) {
+  try {
+    const result = await execFileAsync("scutil", ["--proxy"], {
+      timeout: SYSTEM_PROXY_TIMEOUT_MS
+    });
+    const prefix = target.protocol === "https:" ? "HTTPS" : "HTTP";
+    if (readScutilValue(result.stdout, `${prefix}Enable`) !== "1") {
+      return {};
+    }
+    const host = readScutilValue(result.stdout, `${prefix}Proxy`);
+    const port = readScutilValue(result.stdout, `${prefix}Port`);
+    return host && port ? { proxyUrl: `http://${host}:${port}` } : {};
+  } catch {
+    return {};
+  }
+}
+function readScutilValue(output, key) {
+  return output.match(new RegExp(`^\\s*${key}\\s*:\\s*(.+)$`, "m"))?.[1]?.trim();
+}
+async function detectLinuxProxy(target) {
+  try {
+    const mode = stripQuotes(await queryGSettings("org.gnome.system.proxy", "mode"));
+    if (mode !== "manual") {
+      return {};
+    }
+    const protocol = target.protocol === "https:" ? "https" : "http";
+    const [hostValue, portValue, ignoredHostsValue] = await Promise.all([
+      queryGSettings(`org.gnome.system.proxy.${protocol}`, "host"),
+      queryGSettings(`org.gnome.system.proxy.${protocol}`, "port"),
+      queryGSettings("org.gnome.system.proxy", "ignore-hosts")
+    ]);
+    const host = stripQuotes(hostValue);
+    const port = Number.parseInt(portValue.trim(), 10);
+    if (!host || !Number.isInteger(port) || port <= 0) {
+      return {};
+    }
+    return {
+      noProxy: Array.from(
+        ignoredHostsValue.matchAll(/'([^']+)'/g),
+        (match) => match[1]
+      ).join(","),
+      proxyUrl: `http://${host}:${port}`
+    };
+  } catch {
+    return {};
+  }
+}
+async function queryGSettings(schema, key) {
+  const result = await execFileAsync("gsettings", ["get", schema, key], {
+    timeout: SYSTEM_PROXY_TIMEOUT_MS
+  });
+  return result.stdout;
+}
+function stripQuotes(value) {
+  return value.trim().replace(/^['"]|['"]$/g, "");
+}
+function normalizeProxyUrl(proxyAddress) {
+  return /^[a-z][a-z\d+.-]*:\/\//i.test(proxyAddress) ? proxyAddress : `http://${proxyAddress}`;
+}
+
+// src/utils/http.ts
+var networkOptions = {};
+function configureNetwork(options) {
+  if (options.proxy) {
+    validateProxyUrl(options.proxy);
+  }
+  networkOptions = { ...options };
+}
+async function requestBuffer(url, options) {
+  const startedAt = performance.now();
+  let lastError;
+  const proxyConfig = await resolveProxyConfig(url);
+  for (let attempt = 0; attempt <= options.retries; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+    const dispatcher = proxyConfig.createDispatcher?.();
+    debugNetworkRoute(url, proxyConfig.route, attempt + 1, options.retries + 1);
+    try {
+      const response = await undiciFetch(url, {
+        ...dispatcher ? { dispatcher } : {},
+        headers: options.headers,
+        redirect: "follow",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status} ${response.statusText}`);
+      }
+      return {
+        body: Buffer.from(await response.arrayBuffer()),
+        elapsedMs: Math.round(performance.now() - startedAt),
+        route: proxyConfig.route,
+        status: response.status
+      };
+    } catch (error) {
+      lastError = error;
+      if (attempt < options.retries) {
+        await delay(250 * (attempt + 1));
+      }
+    } finally {
+      clearTimeout(timeout);
+      await dispatcher?.destroy();
+    }
+  }
+  throw createRequestError(url, options, proxyConfig.route, lastError);
+}
+async function resolveProxyConfig(url) {
+  const target = new URL(url);
+  if (networkOptions.forceDirect) {
+    return { route: "direct" };
+  }
+  if (networkOptions.proxy) {
+    const proxyUrl = networkOptions.proxy;
+    return {
+      createDispatcher: () => new ProxyAgent({ uri: proxyUrl }),
+      proxyUrl,
+      route: "proxy-environment"
+    };
+  }
+  const httpProxy = readEnvironmentVariable("http_proxy", "HTTP_PROXY");
+  const httpsProxy = readEnvironmentVariable("https_proxy", "HTTPS_PROXY");
+  const noProxy = readEnvironmentVariable("no_proxy", "NO_PROXY");
+  const environmentProxy = target.protocol === "https:" ? httpsProxy ?? httpProxy : httpProxy;
+  if (noProxy && shouldBypassProxy(target, noProxy)) {
+    return { route: "direct" };
+  }
+  if (environmentProxy) {
+    return {
+      createDispatcher: () => new EnvHttpProxyAgent({
+        httpProxy,
+        httpsProxy,
+        noProxy
+      }),
+      proxyUrl: environmentProxy,
+      route: "proxy-environment"
+    };
+  }
+  const systemProxy = await getSystemProxy(target);
+  if (systemProxy.noProxy && shouldBypassProxy(target, systemProxy.noProxy)) {
+    return { route: "direct" };
+  }
+  if (systemProxy.proxyUrl) {
+    return {
+      createDispatcher: () => new ProxyAgent({ uri: systemProxy.proxyUrl }),
+      proxyUrl: systemProxy.proxyUrl,
+      route: "proxy-system"
+    };
+  }
+  return { route: "direct" };
+}
+async function resolveGitNetworkConfig(repositoryUrl) {
+  if (!/^https?:\/\//i.test(repositoryUrl)) {
+    return { args: [], route: "ssh" };
+  }
+  const proxyConfig = await resolveProxyConfig(repositoryUrl);
+  if (proxyConfig.proxyUrl) {
+    return {
+      args: ["-c", `http.proxy=${proxyConfig.proxyUrl}`],
+      route: proxyConfig.route
+    };
+  }
+  return {
+    args: networkOptions.forceDirect ? ["-c", "http.proxy="] : [],
+    route: "direct"
+  };
+}
+function readEnvironmentVariable(primaryName, fallbackName) {
+  const value = process.env[primaryName] ?? process.env[fallbackName];
+  return value?.trim() || void 0;
+}
+function shouldBypassProxy(target, noProxy) {
+  const hostname = target.hostname.toLowerCase();
+  const port = Number.parseInt(target.port, 10) || (target.protocol === "https:" ? 443 : 80);
+  return noProxy.split(/[,\s]/).some((rawEntry) => {
+    const entry = rawEntry.trim().toLowerCase();
+    if (!entry) {
+      return false;
+    }
+    if (entry === "*") {
+      return true;
+    }
+    const parsed = entry.match(/^(.+):(\d+)$/);
+    const entryHostname = parsed ? parsed[1] : entry;
+    const entryPort = parsed ? Number.parseInt(parsed[2], 10) : 0;
+    if (entryPort && entryPort !== port) {
+      return false;
+    }
+    if (!/^[.*]/.test(entryHostname)) {
+      return hostname === entryHostname;
+    }
+    return hostname.endsWith(entryHostname.replace(/^\*/, ""));
+  });
+}
+function formatNetworkRoute(route) {
+  if (route === "proxy-environment") {
+    return "\u73AF\u5883\u53D8\u91CF\u4EE3\u7406";
+  }
+  if (route === "proxy-system") {
+    return "\u7CFB\u7EDF\u4EE3\u7406";
+  }
+  return "\u76F4\u8FDE";
+}
+function createRequestError(url, options, route, error) {
+  const cause = getErrorMessage(error);
+  return new Error(
+    `\u8BF7\u6C42\u5931\u8D25
+url: ${url}
+error: ${cause}
+network: ${formatNetworkRoute(route)}
+timeout: ${options.timeoutMs} ms
+attempts: ${options.retries + 1}`
+  );
+}
+function validateProxyUrl(proxyUrl) {
+  try {
+    const parsed = new URL(proxyUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error();
+    }
+  } catch {
+    throw new Error("\u65E0\u6548\u7684\u4EE3\u7406\u5730\u5740\uFF0C\u8BF7\u4F7F\u7528 http://host:port \u6216 https://host:port \u683C\u5F0F\u3002");
+  }
+}
+function debugNetworkRoute(url, route, attempt, attempts) {
+  if (process.env.GZ_CLI_FRONT_DEBUG !== "1") {
+    return;
+  }
+  console.log(`[network] host: ${new URL(url).host}`);
+  console.log(`[network] route: ${formatNetworkRoute(route)}`);
+  console.log(`[network] attempt: ${attempt}/${attempts}`);
+}
+function getErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return "\u672A\u77E5\u9519\u8BEF";
+  }
+  const cause = "cause" in error ? error.cause : void 0;
+  const causeMessage = cause instanceof Error ? cause.message : String(cause ?? "");
+  return causeMessage ? `${error.message} (${causeMessage})` : error.message;
+}
+
+// src/utils/git-repository.ts
+import { execa } from "execa";
+import fs3 from "fs-extra";
+import { randomUUID } from "crypto";
+import path4 from "path";
+import { performance as performance2 } from "perf_hooks";
+import { setTimeout as delay2 } from "timers/promises";
+var GIT_OPERATION_ATTEMPTS = 2;
+var GIT_AUTH_TIMEOUT_MS = 6e4;
+var GIT_SSH_CLONE_TIMEOUT_MS = 2e4;
+async function ensureGitRepository(repositoryUrl, options) {
+  const version = normalizeVersion(options.version);
+  const repositoryPath = getRepositoryCachePath(repositoryUrl, options.namespace, version);
+  const startedAt = performance2.now();
+  const cacheExists = await isValidGitCache(repositoryPath);
+  if (await canUseGitCache(repositoryPath, cacheExists, version, options)) {
+    return createCacheResult(repositoryPath, startedAt, false);
+  }
+  const temporaryPath = `${repositoryPath}.${randomUUID()}.tmp`;
+  const candidates = getRepositoryCandidates(repositoryUrl);
+  let lastError;
+  await fs3.ensureDir(path4.dirname(repositoryPath));
+  for (const [index, candidate] of candidates.entries()) {
+    try {
+      const network = await resolveGitNetworkConfig(candidate);
+      const isSshCandidate = network.route === "ssh";
+      const timeoutMs = isSshCandidate ? GIT_SSH_CLONE_TIMEOUT_MS : GIT_AUTH_TIMEOUT_MS;
+      debugGitRepository(candidate, network.route, timeoutMs);
+      await cloneRepository(
+        candidate,
+        temporaryPath,
+        version,
+        network.args,
+        timeoutMs,
+        isSshCandidate ? 1 : GIT_OPERATION_ATTEMPTS
+      );
+      await replaceCacheDirectory(temporaryPath, repositoryPath);
+      return {
+        cacheHit: false,
+        elapsedMs: Math.round(performance2.now() - startedAt),
+        path: repositoryPath,
+        route: network.route,
+        staleCache: false
+      };
+    } catch (error) {
+      lastError = error;
+      await fs3.remove(temporaryPath);
+      if (index < candidates.length - 1) {
+        if (process.env.GZ_CLI_FRONT_DEBUG === "1") {
+          console.log("[git] SSH \u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u5C1D\u8BD5 HTTPS...");
+        }
+        continue;
+      }
+    }
+  }
+  if (cacheExists && !options.forceRefresh) {
+    return createCacheResult(repositoryPath, startedAt, true);
+  }
+  throw createGitError(repositoryUrl, lastError, "clone");
+}
+function getRepositoryCachePath(repositoryUrl, namespace, version) {
+  return getGitRepositoryCachePath(
+    namespace,
+    `${getRepositoryIdentity(repositoryUrl)}#${version ?? "latest"}`
+  );
+}
+function getRepositoryCandidates(repositoryUrl) {
+  return [repositoryUrl];
+}
+function getRepositoryIdentity(repositoryUrl) {
+  try {
+    const parsed = new URL(repositoryUrl);
+    const repositoryPath = parsed.pathname.replace(/^\/|\/$/g, "").replace(/\.git$/i, "");
+    return `${parsed.hostname.toLowerCase()}/${repositoryPath}`;
+  } catch {
+    const sshMatch = repositoryUrl.match(/^[^@]+@([^:]+):(.+)$/);
+    if (!sshMatch) {
+      return repositoryUrl;
+    }
+    return `${sshMatch[1].toLowerCase()}/${sshMatch[2].replace(/\.git$/i, "")}`;
+  }
+}
+async function canUseGitCache(repositoryPath, cacheExists, version, options) {
+  if (options.forceRefresh || !cacheExists) {
+    return false;
+  }
+  const stats = await fs3.stat(repositoryPath);
+  return Boolean(version) || isCacheFresh(stats.mtimeMs, options.ttlMs);
+}
+function debugGitRepository(repositoryUrl, route, timeoutMs) {
+  if (process.env.GZ_CLI_FRONT_DEBUG !== "1") {
+    return;
+  }
+  const routeLabel = route === "ssh" ? "Git/SSH" : formatNetworkRoute(route);
+  console.log(`[git] host: ${getRepositoryHost(repositoryUrl)}`);
+  console.log(`[git] route: ${routeLabel}`);
+  console.log(`[git] timeout: ${timeoutMs} ms`);
+}
+function getRepositoryHost(repositoryUrl) {
+  try {
+    return new URL(repositoryUrl).host;
+  } catch {
+    return repositoryUrl.match(/^[^@]+@([^:]+):/)?.[1] ?? "unknown";
+  }
+}
+async function cloneRepository(repositoryUrl, targetPath, version, networkArgs, timeoutMs, attempts) {
+  const args = [
+    ...networkArgs,
+    "clone",
+    "--quiet",
+    "--depth",
+    "1",
+    "--single-branch"
+  ];
+  if (version) {
+    args.push("--branch", version);
+  }
+  args.push(repositoryUrl, targetPath);
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      await execa("git", args, {
+        forceKillAfterDelay: 1e3,
+        stdin: "inherit",
+        stdout: "pipe",
+        stderr: ["pipe", "inherit"],
+        timeout: timeoutMs,
+        windowsHide: true
+      });
+      return;
+    } catch (error) {
+      if (attempt === attempts || !isTransientGitError(error)) {
+        throw error;
+      }
+      if (process.env.GZ_CLI_FRONT_DEBUG === "1") {
+        console.log(`[git] transient failure, retry: ${attempt + 1}/${attempts}`);
+      }
+      await fs3.remove(targetPath);
+      await delay2(300);
+    }
+  }
+}
+function isTransientGitError(error) {
+  if (typeof error === "object" && error !== null && error.timedOut === true) {
+    return true;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return [
+    /SSL\/TLS connection failed/i,
+    /failed to receive handshake/i,
+    /connection (?:was )?reset/i,
+    /remote end hung up unexpectedly/i,
+    /early EOF/i,
+    /failed to connect/i,
+    /could not resolve host/i,
+    /timed out|timeout/i
+  ].some((pattern) => pattern.test(message));
+}
+async function replaceCacheDirectory(sourcePath, targetPath) {
+  const backupPath = `${targetPath}.${randomUUID()}.bak`;
+  const targetExists = await fs3.pathExists(targetPath);
+  if (targetExists) {
+    await fs3.move(targetPath, backupPath);
+  }
+  try {
+    await fs3.move(sourcePath, targetPath);
+    await fs3.remove(backupPath);
+  } catch (error) {
+    await fs3.remove(targetPath);
+    if (await fs3.pathExists(backupPath)) {
+      await fs3.move(backupPath, targetPath);
+    }
+    throw error;
+  }
+}
+async function isValidGitCache(repositoryPath) {
+  return fs3.pathExists(path4.join(repositoryPath, ".git"));
+}
+function createCacheResult(repositoryPath, startedAt, staleCache) {
+  return {
+    cacheHit: true,
+    elapsedMs: Math.round(performance2.now() - startedAt),
+    path: repositoryPath,
+    route: staleCache ? "stale-cache" : "cache",
+    staleCache
+  };
+}
+function normalizeVersion(version) {
+  return version && version !== "latest" ? version : void 0;
+}
+function createGitError(repositoryUrl, error, stage) {
+  const message = getGitErrorMessage(error);
+  const safeRepository = sanitizeRepositoryUrl(repositoryUrl);
+  debugGitFailure(stage, message);
+  if (isGitTimeoutError(error, message)) {
+    return new Error(
+      `Git \u4ED3\u5E93\u8FDE\u63A5\u8D85\u65F6\uFF08\u9636\u6BB5\uFF1A${stage}\uFF0C${GIT_AUTH_TIMEOUT_MS} ms\uFF09\uFF1A${safeRepository}
+\u8BF7\u68C0\u67E5\u5F53\u524D\u7F51\u7EDC\u6216\u4EE3\u7406\u8BBE\u7F6E\u540E\u91CD\u8BD5\u3002`
+    );
+  }
+  if (isGitPermissionError(message)) {
+    return new Error(
+      `\u65E0\u6CD5\u8BBF\u95EE Git \u4ED3\u5E93\uFF08\u9636\u6BB5\uFF1A${stage}\uFF09\uFF1A${safeRepository}
+\u8BF7\u68C0\u67E5\u4ED3\u5E93\u5730\u5740\u3001\u7F51\u7EDC\u8FDE\u63A5\u53CA\u5F53\u524D Git \u51ED\u636E\u540E\u91CD\u8BD5\u3002`
+    );
+  }
+  return new Error(
+    `Git \u4ED3\u5E93\u8BBF\u95EE\u5931\u8D25\uFF08\u9636\u6BB5\uFF1A${stage}\uFF09\uFF1A${safeRepository}
+\u8BF7\u786E\u8BA4\u5DF2\u5B89\u88C5 Git\uFF0C\u4E14\u5F53\u524D Git/SSH \u8D26\u53F7\u62E5\u6709\u4ED3\u5E93 Read \u6743\u9650\u3002
+${message}`
+  );
+}
+function getGitErrorMessage(error) {
+  return redactCredentials(error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF");
+}
+function debugGitFailure(stage, message) {
+  if (process.env.GZ_CLI_FRONT_DEBUG !== "1") {
+    return;
+  }
+  console.error(`[git] failed stage: ${stage}`);
+  console.error(`[git] error: ${message}`);
+}
+function isGitTimeoutError(error, message) {
+  if (typeof error === "object" && error !== null && error.timedOut === true) {
+    return true;
+  }
+  return /timed out|timeout/i.test(message);
+}
+function isGitPermissionError(message) {
+  return [
+    /authentication failed/i,
+    /permission denied/i,
+    /repository not found/i,
+    /could not read username/i,
+    /unable to get (?:password|username) from user/i,
+    /terminal prompts disabled/i,
+    /user interaction is disabled/i,
+    /interactive prompts are disabled/i,
+    /credential.*(?:failed|unavailable)/i,
+    /access denied/i,
+    /http (?:error )?40[13]/i,
+    /status code: 40[13]/i
+  ].some((pattern) => pattern.test(message));
+}
+function redactCredentials(message) {
+  return message.replace(/http\.proxy=\S+/gi, "http.proxy=***").replace(/(https?:\/\/)[^@\s/]+@/gi, "$1***@");
+}
+function sanitizeRepositoryUrl(repositoryUrl) {
+  try {
+    const parsed = new URL(repositoryUrl);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    return repositoryUrl;
+  }
+}
+
+// src/utils/template.ts
+var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".md",
+  ".html",
+  ".css",
+  ".less",
+  ".scss",
+  ".env"
+]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
+var TEMPLATE_DEBUG_ENV = "GZ_CLI_FRONT_DEBUG";
+var TEMPLATE_REGISTRY_TIMEOUT_MS = 5e3;
+async function fetchTemplates(templateRegistry, options = {}) {
+  const registry = typeof templateRegistry === "string" ? { url: templateRegistry } : templateRegistry;
+  if (registry.source === "git") {
+    return fetchTemplatesFromGit(registry, options);
+  }
+  return fetchTemplatesFromHttp(registry.url, options);
+}
+async function fetchTemplatesFromHttp(templateRegistryUrl, options) {
+  const cachePath = getTemplateRegistryCachePath(templateRegistryUrl);
+  const cacheStartedAt = performance3.now();
+  let cached = await readRegistryCache(cachePath, templateRegistryUrl);
+  const cacheReadMs = Math.round(performance3.now() - cacheStartedAt);
+  debugTemplateRequest(templateRegistryUrl, cachePath, options.forceRefresh === true);
+  if (!options.forceRefresh && cached && isCacheFresh(cached.fetchedAt, TEMPLATE_REGISTRY_CACHE_TTL_MS)) {
+    try {
+      return parseTemplates(cached.body, true, false, cacheReadMs, "cache");
+    } catch {
+      await fs4.remove(cachePath);
+      cached = void 0;
+    }
+  }
+  const fetchStartedAt = performance3.now();
+  try {
+    const response = await requestBuffer(templateRegistryUrl, {
+      retries: 1,
+      timeoutMs: TEMPLATE_REGISTRY_TIMEOUT_MS
+    });
+    const body = response.body.toString("utf8");
+    const result = parseTemplates(body, false, false, response.elapsedMs, response.route);
+    try {
+      await writeRegistryCache(cachePath, {
+        body,
+        fetchedAt: Date.now(),
+        url: templateRegistryUrl
+      });
+    } catch (error) {
+      if (process.env[TEMPLATE_DEBUG_ENV] === "1") {
+        console.log(`template config cache write failed: ${getErrorMessage2(error)}`);
+      }
+    }
+    return result;
+  } catch (error) {
+    if (!options.forceRefresh && cached) {
+      return parseTemplates(
+        cached.body,
+        true,
+        true,
+        Math.round(performance3.now() - fetchStartedAt),
+        "stale-cache"
+      );
+    }
+    throw createTemplateRequestError(templateRegistryUrl, error);
+  }
+}
+async function fetchTemplatesFromGit(registry, options) {
+  const cacheKey = `git:${registry.url}#${registry.version ?? "latest"}:${registry.file}`;
+  const fallbackCachePath = getTemplateRegistryCachePath(cacheKey);
+  const fallbackCache = await readRegistryCache(fallbackCachePath, cacheKey);
+  const startedAt = performance3.now();
+  try {
+    const result = await ensureGitRepository(registry.url, {
+      forceRefresh: options.forceRefresh,
+      namespace: "registry",
+      ttlMs: TEMPLATE_REGISTRY_CACHE_TTL_MS,
+      version: registry.version
+    });
+    const registryFile = resolveRegistryFile(result.path, registry.file);
+    const body = await fs4.readFile(registryFile, "utf8");
+    const parsed = parseTemplates(
+      body,
+      result.cacheHit,
+      result.staleCache,
+      result.elapsedMs,
+      result.route
+    );
+    if (!result.cacheHit || !fallbackCache) {
+      await writeRegistryCache(fallbackCachePath, {
+        body,
+        fetchedAt: Date.now(),
+        url: cacheKey
+      }).catch(() => void 0);
+    }
+    return parsed;
+  } catch (error) {
+    if (!options.forceRefresh && fallbackCache) {
+      return parseTemplates(
+        fallbackCache.body,
+        true,
+        true,
+        Math.round(performance3.now() - startedAt),
+        "stale-cache"
+      );
+    }
+    throw new Error(`\u6A21\u677F\u6CE8\u518C\u4ED3\u5E93\u8BFB\u53D6\u5931\u8D25
+error: ${getErrorMessage2(error)}`);
+  }
+}
+function resolveRegistryFile(repositoryPath, registryFile) {
+  const resolvedRepository = path5.resolve(repositoryPath);
+  const resolvedFile = path5.resolve(repositoryPath, registryFile);
+  if (resolvedFile !== resolvedRepository && !resolvedFile.startsWith(`${resolvedRepository}${path5.sep}`)) {
+    throw new Error(`\u6A21\u677F\u6CE8\u518C\u6587\u4EF6\u5FC5\u987B\u4F4D\u4E8E\u6CE8\u518C\u4ED3\u5E93\u5185\uFF1A${registryFile}`);
+  }
+  return resolvedFile;
+}
+function parseTemplates(body, cacheHit, staleCache, fetchMs, route) {
+  const parseStartedAt = performance3.now();
+  let data;
+  try {
+    data = JSON.parse(body);
+  } catch (error) {
+    throw new Error(`\u6A21\u677F\u914D\u7F6E JSON \u89E3\u6790\u5931\u8D25\uFF1A${getErrorMessage2(error)}`);
+  }
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new Error("\u6A21\u677F\u6CE8\u518C\u8868\u4E3A\u7A7A");
+  }
+  const templates = data.filter(isTemplateMeta);
+  if (templates.length === 0) {
+    throw new Error("\u6A21\u677F\u6CE8\u518C\u8868\u4E2D\u6CA1\u6709\u6709\u6548\u6A21\u677F");
+  }
+  return {
+    cacheHit,
+    fetchMs,
+    parseMs: Math.round(performance3.now() - parseStartedAt),
+    route,
+    staleCache,
+    templates
+  };
+}
+function debugTemplateRequest(templateRegistryUrl, cachePath, forceRefresh) {
+  if (process.env[TEMPLATE_DEBUG_ENV] !== "1") {
+    return;
+  }
+  console.log("template config url:", templateRegistryUrl);
+  console.log("template config client: undici fetch");
+  console.log(`template config timeout: ${TEMPLATE_REGISTRY_TIMEOUT_MS} ms`);
+  console.log("template config cache:", cachePath);
+  console.log("template config force refresh:", forceRefresh);
+}
+function createTemplateRequestError(templateRegistryUrl, error) {
+  return new Error(
+    `\u6A21\u677F\u914D\u7F6E\u8BF7\u6C42\u5931\u8D25
+url: ${templateRegistryUrl}
+error: ${getErrorMessage2(error)}`
+  );
+}
+function getErrorMessage2(error) {
+  if (!(error instanceof Error)) {
+    return "\u672A\u77E5\u9519\u8BEF";
+  }
+  const cause = "cause" in error ? error.cause : void 0;
+  const causeMessage = cause instanceof Error ? cause.message : String(cause ?? "");
+  return causeMessage ? `${error.message} (${causeMessage})` : error.message;
+}
+async function readRegistryCache(cachePath, templateRegistryUrl) {
+  try {
+    const cache = await fs4.readJson(cachePath);
+    if (!isRecord(cache) || cache.url !== templateRegistryUrl || typeof cache.body !== "string" || typeof cache.fetchedAt !== "number") {
+      return void 0;
+    }
+    return {
+      body: cache.body,
+      fetchedAt: cache.fetchedAt,
+      url: cache.url
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeRegistryCache(cachePath, cache) {
+  await fs4.ensureDir(path5.dirname(cachePath));
+  await fs4.writeJson(cachePath, cache);
+}
+async function replaceTemplateVariables(targetDir, variables) {
+  await visitDirectory(targetDir, async (filePath) => {
+    if (!shouldProcessFile(filePath)) {
+      return;
+    }
+    const content = await fs4.readFile(filePath, "utf8");
+    const replaced = Object.entries(variables).reduce(
+      (result, [key, value]) => result.split(`{{ ${key} }}`).join(value),
+      content
+    );
+    if (replaced !== content) {
+      await fs4.writeFile(filePath, replaced, "utf8");
+    }
+  });
+}
+async function visitDirectory(directory, onFile) {
+  const entries = await fs4.readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path5.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!IGNORED_DIRECTORIES.has(entry.name)) {
+        await visitDirectory(entryPath, onFile);
+      }
+    } else if (entry.isFile()) {
+      await onFile(entryPath);
+    }
+  }
+}
+function shouldProcessFile(filePath) {
+  const filename = path5.basename(filePath);
+  return TEXT_FILE_EXTENSIONS.has(path5.extname(filename)) || filename.startsWith(".env");
+}
+function isTemplateMeta(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return isString(value.name) && isString(value.label) && isString(value.description) && isTemplateType(value.type) && isTemplateLocation(value) && (value.version === void 0 || isString(value.version));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isTemplateType(value) {
+  return value === "main" || value === "micro";
+}
+function isTemplateLocation(value) {
+  if (value.source !== void 0 && !isTemplateSource(value.source)) {
+    return false;
+  }
+  if (isString(value.url)) {
+    return true;
+  }
+  return value.source === void 0 && isString(value.repo);
+}
+function isTemplateSource(value) {
+  return value === "github" || value === "gitlab" || value === "git";
+}
+
+// src/utils/template-downloader.ts
+import fs5 from "fs-extra";
+import { randomUUID as randomUUID2 } from "crypto";
+import path6 from "path";
+import { performance as performance4 } from "perf_hooks";
+import { x as extractTar } from "tar";
+var TEMPLATE_DOWNLOAD_TIMEOUT_MS = 12e3;
+var DOWNLOADERS = {
+  github: downloadFromGitHub,
+  gitlab: downloadFromGit,
+  git: downloadFromGit
+};
+async function downloadTemplate(template, targetDir, options = {}) {
+  const source = template.source ?? "github";
+  return DOWNLOADERS[source](template, targetDir, options);
+}
+async function downloadFromGitHub(template, targetDir, options) {
+  const repository = normalizeGitHubRepository(getTemplateUrl(template));
+  const version = template.version && template.version !== "latest" ? template.version : void 0;
+  const sourceKey = `${repository}${version ? `#${version}` : "#latest"}`;
+  const archivePath = getTemplateArchiveCachePath(sourceKey);
+  const archive = await ensureGitHubArchive(
+    repository,
+    version,
+    archivePath,
+    options.forceRefresh === true
+  );
+  const extractStartedAt = performance4.now();
+  await fs5.ensureDir(targetDir);
+  try {
+    await extractTar({
+      cwd: targetDir,
+      file: archivePath,
+      preservePaths: false,
+      strict: true,
+      strip: 1
+    });
+  } catch (error) {
+    if (!archive.cacheHit) {
+      throw error;
+    }
+    await fs5.remove(archivePath);
+    await fs5.emptyDir(targetDir);
+    return downloadFromGitHub(template, targetDir, { forceRefresh: true });
+  }
+  return {
+    cacheHit: archive.cacheHit,
+    copyMs: 0,
+    downloadMs: archive.downloadMs,
+    extractMs: Math.round(performance4.now() - extractStartedAt),
+    route: archive.route
+  };
+}
+async function downloadFromGit(template, targetDir, options) {
+  if (!template.url) {
+    throw new Error(`${template.source} \u6A21\u677F\u5FC5\u987B\u63D0\u4F9B Git clone URL\u3002`);
+  }
+  const repository = await ensureGitRepository(template.url, {
+    forceRefresh: options.forceRefresh,
+    namespace: "templates",
+    ttlMs: TEMPLATE_ARCHIVE_CACHE_TTL_MS,
+    version: template.version
+  });
+  const copyStartedAt = performance4.now();
+  await fs5.copy(repository.path, targetDir, {
+    filter: (sourcePath) => path6.basename(sourcePath) !== ".git"
+  });
+  return {
+    cacheHit: repository.cacheHit,
+    copyMs: Math.round(performance4.now() - copyStartedAt),
+    downloadMs: repository.elapsedMs,
+    extractMs: 0,
+    route: repository.route
+  };
+}
+async function ensureGitHubArchive(repository, version, archivePath, forceRefresh) {
+  const startedAt = performance4.now();
+  if (!forceRefresh && await canUseArchiveCache(archivePath, Boolean(version))) {
+    return {
+      cacheHit: true,
+      downloadMs: Math.round(performance4.now() - startedAt),
+      route: "cache"
+    };
+  }
+  const archiveRequest = createGitHubArchiveRequest(repository, version);
+  const response = await requestBuffer(archiveRequest.url, {
+    headers: archiveRequest.headers,
+    retries: 1,
+    timeoutMs: TEMPLATE_DOWNLOAD_TIMEOUT_MS
+  });
+  const temporaryPath = `${archivePath}.${randomUUID2()}.tmp`;
+  await fs5.ensureDir(path6.dirname(archivePath));
+  try {
+    await fs5.writeFile(temporaryPath, response.body);
+    await fs5.move(temporaryPath, archivePath, { overwrite: true });
+  } finally {
+    await fs5.remove(temporaryPath);
+  }
+  return {
+    cacheHit: false,
+    downloadMs: Math.round(performance4.now() - startedAt),
+    route: response.route
+  };
+}
+function createGitHubArchiveRequest(repository, version) {
+  const token = process.env.GITHUB_TOKEN?.trim();
+  if (token) {
+    return {
+      headers: createGitHubApiHeaders(token),
+      url: `https://api.github.com/repos/${repository}/tarball${version ? `/${encodeURIComponent(version)}` : ""}`
+    };
+  }
+  return {
+    headers: { "user-agent": "gz-cli-front" },
+    url: `https://codeload.github.com/${repository}/tar.gz/${encodeURIComponent(version ?? "HEAD")}`
+  };
+}
+async function canUseArchiveCache(archivePath, immutableVersion) {
+  try {
+    const stats = await fs5.stat(archivePath);
+    return stats.isFile() && (immutableVersion || isCacheFresh(stats.mtimeMs, TEMPLATE_ARCHIVE_CACHE_TTL_MS));
+  } catch {
+    return false;
+  }
+}
+function normalizeGitHubRepository(repository) {
+  const normalized = repository.replace(/^https:\/\/github\.com\//i, "").replace(/\.git$/i, "").replace(/^\/+|\/+$/g, "");
+  if (!/^[^/\s]+\/[^/\s]+$/.test(normalized)) {
+    throw new Error(`\u65E0\u6548\u7684 GitHub \u6A21\u677F\u5730\u5740\uFF1A${repository}`);
+  }
+  return normalized;
+}
+function createGitHubApiHeaders(token) {
+  return {
+    accept: "application/vnd.github+json",
+    authorization: `Bearer ${token}`,
+    "user-agent": "gz-cli-front",
+    "x-github-api-version": "2022-11-28"
+  };
+}
+function getTemplateUrl(template) {
+  if (template.url) {
+    return template.url;
+  }
+  if (template.repo) {
+    return template.repo;
+  }
+  throw new Error("\u6A21\u677F\u914D\u7F6E\u7F3A\u5C11 url\u3002");
+}
+
+// src/utils/stable-spinner.ts
+import chalk from "chalk";
+import { clearLine, cursorTo } from "readline";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 80;
+var RESTORE_CURSOR = "\x1B[u";
+var SAVE_CURSOR = "\x1B[s";
+function createStableSpinner() {
+  return new StableTextSpinner(process.stderr);
+}
+var StableTextSpinner = class {
+  constructor(stream) {
+    this.frameIndex = 0;
+    this.value = "";
+    this.stream = stream;
+  }
+  get isSpinning() {
+    return this.interval !== void 0;
+  }
+  get text() {
+    return this.value;
+  }
+  set text(value) {
+    this.value = value;
+    if (this.isSpinning) {
+      this.renderLine();
+    }
+  }
+  start(text) {
+    if (text !== void 0) {
+      this.value = text;
+    }
+    if (!this.stream.isTTY || this.isSpinning) {
+      if (!this.stream.isTTY && this.value) {
+        this.stream.write(`- ${this.value}
+`);
+      }
+      return;
+    }
+    this.stream.write(
+      `${chalk.cyan(SPINNER_FRAMES[this.frameIndex])} ${this.value}${SAVE_CURSOR}`
+    );
+    this.interval = setInterval(() => this.renderFrame(), SPINNER_INTERVAL_MS);
+  }
+  succeed(text) {
+    this.persist(chalk.green("\u2714"), text);
+  }
+  fail(text) {
+    this.persist(chalk.red("\u2716"), text);
+  }
+  renderLine() {
+    this.restoreAndClearLine();
+    this.stream.write(`${chalk.cyan(SPINNER_FRAMES[this.frameIndex])} ${this.value}${SAVE_CURSOR}`);
+  }
+  renderFrame() {
+    this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+    this.stream.write(
+      `${RESTORE_CURSOR}\r${chalk.cyan(SPINNER_FRAMES[this.frameIndex])}${RESTORE_CURSOR}`
+    );
+  }
+  persist(symbol, text) {
+    const finalText = text ?? this.value;
+    this.stop();
+    this.stream.write(`${symbol}${finalText ? ` ${finalText}` : ""}
+`);
+  }
+  stop() {
+    if (!this.interval) {
+      return false;
+    }
+    clearInterval(this.interval);
+    this.interval = void 0;
+    this.restoreAndClearLine();
+    return true;
+  }
+  restoreAndClearLine() {
+    this.stream.write(RESTORE_CURSOR);
+    cursorTo(this.stream, 0);
+    clearLine(this.stream, 0);
+  }
+};
+
+// src/commands/create.ts
+async function create(projectName, options = {}) {
+  try {
+    configureNetwork({
+      forceDirect: options.proxy === false,
+      proxy: typeof options.proxy === "string" ? options.proxy : void 0
+    });
+    const templateTiming = createTemplateTiming();
+    const context = await createInitContext(projectName, options, templateTiming);
+    const targetPath = path7.resolve(process.cwd(), context.projectName);
+    if (!await prepareTargetDirectory(targetPath, context.projectName)) {
+      return;
+    }
+    const install = await confirm({
+      message: "\u662F\u5426\u81EA\u52A8\u5B89\u88C5\u4F9D\u8D56\uFF1F",
+      default: true
+    });
+    await downloadAndGenerate(context, targetPath, templateTiming, options);
+    await installDependencies(install, targetPath, context.packageManager);
+    await initializeGit(targetPath);
+    printNextSteps(context, install);
+  } catch (error) {
+    if (isUserCancellation(error)) {
+      console.log(chalk2.yellow("\n\u5DF2\u53D6\u6D88\u64CD\u4F5C\u3002"));
+      return;
+    }
+    console.error(chalk2.red(`\u521B\u5EFA\u9879\u76EE\u5931\u8D25\uFF1A${getErrorMessage3(error)}`));
+  }
+}
+async function createInitContext(projectName, options, templateTiming) {
+  const finalProjectName = await getProjectName(projectName);
+  const templates = await loadTemplates(templateTiming, options);
+  const template = await chooseTemplate(templates);
+  return {
+    projectName: finalProjectName,
+    template,
+    packageManager: resolvePackageManager(options.pm)
+  };
+}
+async function getProjectName(projectName) {
+  if (projectName?.trim()) {
+    return projectName.trim();
+  }
+  return input({
+    message: "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0\uFF1A",
+    validate: (value) => value.trim() ? true : "\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"
+  });
+}
+async function loadTemplates(templateTiming, options) {
+  const spinner = createStableSpinner();
+  try {
+    const config = await loadCliConfig();
+    spinner.start("\u6B63\u5728\u83B7\u53D6\u8FDC\u7A0B\u6A21\u677F\u914D\u7F6E...");
+    const result = await fetchTemplates(config.templateRegistry, {
+      forceRefresh: options.refresh === true
+    });
+    assignFetchTiming(templateTiming, result);
+    spinner.succeed("\u8FDC\u7A0B\u6A21\u677F\u914D\u7F6E\u83B7\u53D6\u6210\u529F");
+    if (result.staleCache) {
+      console.log(chalk2.yellow("\u8FDC\u7A0B\u6A21\u677F\u914D\u7F6E\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u5DF2\u4F7F\u7528\u672C\u5730\u7F13\u5B58\u3002"));
+    }
+    return result.templates;
+  } catch (error) {
+    if (spinner.isSpinning) {
+      spinner.fail("\u83B7\u53D6\u8FDC\u7A0B\u6A21\u677F\u914D\u7F6E\u5931\u8D25");
+    } else {
+      console.error(chalk2.red("\u83B7\u53D6\u8FDC\u7A0B\u6A21\u677F\u914D\u7F6E\u5931\u8D25"));
+    }
+    const message = error instanceof Error && error.message ? error.message : "\u672A\u77E5\u9519\u8BEF";
+    throw new Error(`\u83B7\u53D6\u8FDC\u7A0B\u6A21\u677F\u914D\u7F6E\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u6A21\u677F\u914D\u7F6E\u5730\u5740\u3002
+${message}`);
+  }
+}
+async function chooseTemplate(templates) {
+  return select({
+    message: "\u8BF7\u9009\u62E9\u9879\u76EE\u6A21\u677F\uFF1A",
+    choices: templates.map((template) => ({
+      name: `${template.label} (${template.name}) - ${template.description}`,
+      value: template
+    })),
+    default: templates.find((template) => template.type === "micro") ?? templates[0]
+  });
+}
+function resolvePackageManager(requestedPackageManager) {
+  if (requestedPackageManager !== void 0) {
+    if (!isPackageManager(requestedPackageManager)) {
+      throw new Error(
+        `\u4E0D\u652F\u6301\u7684 packageManager: ${requestedPackageManager}
+\u652F\u6301: npm\u3001pnpm\u3001yarn`
+      );
+    }
+    return requestedPackageManager;
+  }
+  const packageManager = detectPackageManager();
+  if (packageManager === "npm") {
+    console.log(chalk2.yellow("\u672A\u68C0\u6D4B\u5230 pnpm \u6216 yarn\uFF0C\u81EA\u52A8\u4F7F\u7528 npm\u3002"));
+  }
+  return packageManager;
+}
+async function prepareTargetDirectory(targetPath, projectName) {
+  if (!await fs6.pathExists(targetPath)) {
+    return true;
+  }
+  const overwrite = await confirm({
+    message: `\u76EE\u5F55 ${projectName} \u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6\uFF1F`,
+    default: false
+  });
+  if (!overwrite) {
+    console.log(chalk2.yellow("\u5DF2\u53D6\u6D88\u521B\u5EFA\u3002"));
+    return false;
+  }
+  await fs6.remove(targetPath);
+  return true;
+}
+async function downloadAndGenerate(context, targetPath, templateTiming, options) {
+  const { template, projectName, packageManager } = context;
+  const spinner = createStableSpinner();
+  const downloadStartedAt = performance5.now();
+  try {
+    spinner.start(`\u6B63\u5728\u4E0B\u8F7D\u6A21\u677F ${template.label}...`);
+    const downloadTiming = await downloadTemplate(template, targetPath, {
+      forceRefresh: options.refresh === true
+    });
+    assignDownloadTiming(templateTiming, downloadTiming);
+  } catch (error) {
+    templateTiming.downloadMs = Math.round(performance5.now() - downloadStartedAt);
+    await fs6.remove(targetPath);
+    if (spinner.isSpinning) {
+      spinner.fail("\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25");
+    } else {
+      console.error(chalk2.red("\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25"));
+    }
+    printTemplateTiming(templateTiming);
+    const message = error instanceof Error && error.message ? error.message : "\u672A\u77E5\u9519\u8BEF";
+    throw new Error(`\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u4ED3\u5E93\u5730\u5740\u6216\u7F51\u7EDC\u8FDE\u63A5\u3002
+${message}`);
+  }
+  try {
+    spinner.text = "\u6B63\u5728\u66FF\u6362\u6A21\u677F\u53D8\u91CF...";
+    const startedAt = performance5.now();
+    await replaceTemplateVariables(targetPath, { projectName });
+    await updateProjectPackageJson(targetPath, projectName, packageManager);
+    templateTiming.renderMs = Math.round(performance5.now() - startedAt);
+    spinner.succeed("\u6A21\u677F\u4E0B\u8F7D\u5E76\u751F\u6210\u5B8C\u6210");
+    printTemplateTiming(templateTiming);
+  } catch {
+    await fs6.remove(targetPath);
+    spinner.fail("\u6A21\u677F\u4E0B\u8F7D\u6216\u53D8\u91CF\u66FF\u6362\u5931\u8D25");
+    throw new Error("\u6A21\u677F\u53D8\u91CF\u66FF\u6362\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u6A21\u677F\u6587\u4EF6\u5185\u5BB9\u3002");
+  }
+}
+function createTemplateTiming() {
+  return {
+    configRoute: "direct",
+    copyMs: 0,
+    fetchConfigMs: 0,
+    parseConfigMs: 0,
+    templateRoute: "direct",
+    downloadMs: 0,
+    extractMs: 0,
+    renderMs: 0
+  };
+}
+function assignFetchTiming(templateTiming, result) {
+  templateTiming.fetchConfigMs = result.fetchMs;
+  templateTiming.parseConfigMs = result.parseMs;
+  templateTiming.configRoute = result.route;
+}
+function assignDownloadTiming(templateTiming, downloadTiming) {
+  templateTiming.copyMs = downloadTiming.copyMs;
+  templateTiming.downloadMs = downloadTiming.downloadMs;
+  templateTiming.extractMs = downloadTiming.extractMs;
+  templateTiming.templateRoute = downloadTiming.route;
+}
+function printTemplateTiming(templateTiming) {
+  console.log("\n[template]");
+  console.log(`fetch config: ${templateTiming.fetchConfigMs} ms (${formatRoute(templateTiming.configRoute)})`);
+  console.log(`parse config: ${templateTiming.parseConfigMs} ms`);
+  console.log(`download: ${templateTiming.downloadMs} ms (${formatRoute(templateTiming.templateRoute)})`);
+  console.log(`extract: ${templateTiming.extractMs} ms`);
+  console.log(`copy: ${templateTiming.copyMs} ms`);
+  console.log(`render: ${templateTiming.renderMs} ms`);
+}
+function formatRoute(route) {
+  if (route === "proxy-environment") {
+    return "remote, \u73AF\u5883\u53D8\u91CF\u4EE3\u7406";
+  }
+  if (route === "proxy-system") {
+    return "remote, \u7CFB\u7EDF\u4EE3\u7406";
+  }
+  if (route === "direct") {
+    return "remote, \u76F4\u8FDE";
+  }
+  if (route === "ssh") {
+    return "remote, Git/SSH";
+  }
+  return route.replace("-", " ");
+}
+async function installDependencies(install, targetPath, packageManager) {
+  if (!install) {
+    return;
+  }
+  const installCommand = packageManager === "yarn" ? [] : ["install"];
+  const spinner = ora(`\u6B63\u5728\u5B89\u88C5\u4F9D\u8D56 (${packageManager} ${installCommand.join(" ")})...`).start();
+  try {
+    await execa2(packageManager, installCommand, { cwd: targetPath });
+    spinner.succeed("\u4F9D\u8D56\u5B89\u88C5\u6210\u529F");
+  } catch {
+    spinner.warn("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u8FDB\u5165\u9879\u76EE\u76EE\u5F55\u540E\u624B\u52A8\u5B89\u88C5");
+  }
+}
+async function initializeGit(targetPath) {
+  const spinner = ora("\u6B63\u5728\u521D\u59CB\u5316 Git \u4ED3\u5E93...").start();
+  try {
+    await execa2("git", ["init"], { cwd: targetPath });
+    spinner.succeed("Git \u4ED3\u5E93\u521D\u59CB\u5316\u6210\u529F");
+  } catch {
+    spinner.warn("Git \u4ED3\u5E93\u521D\u59CB\u5316\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4 Git \u5DF2\u5B89\u88C5");
+  }
+}
+function printNextSteps(context, installed) {
+  const { projectName, packageManager } = context;
+  const installCommand = packageManager === "yarn" ? "yarn" : `${packageManager} install`;
+  const devCommand = packageManager === "npm" ? "npm run dev" : `${packageManager} dev`;
+  console.log(chalk2.green(`
+\u9879\u76EE ${projectName} \u521B\u5EFA\u6210\u529F\uFF01`));
+  console.log("\n\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5\uFF1A\n");
+  console.log(chalk2.cyan(`  cd ${projectName}`));
+  if (!installed) {
+    console.log(chalk2.cyan(`  ${installCommand}`));
+  }
+  console.log(chalk2.cyan(`  ${devCommand}`));
+}
+function isUserCancellation(error) {
+  return error instanceof Error && /User force closed|User cancelled/i.test(error.message);
+}
+function getErrorMessage3(error) {
+  return error instanceof Error && error.message ? ` ${error.message}` : "";
+}
+
+// src/pre/index.ts
+import chalk3 from "chalk";
+function checkNodeVersion() {
+  const currentVersion = process.version;
+  const version = currentVersion.replace(/^v/, "");
+  const [major] = version.split(".").map(Number);
+  if (major < 22) {
+    console.error(chalk3.red(`
+\u274C \u9519\u8BEF\uFF1A\u5F53\u524D Node.js \u7248\u672C (${currentVersion}) \u8FC7\u4F4E\uFF01`));
+    console.error(chalk3.yellow("\u26A0\uFE0F  \u8BF7\u5347\u7EA7 Node.js \u7248\u672C\uFF0C\u4E0D\u4F4E\u4E8E v22.19.0"));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+checkNodeVersion();
+var program = new Command();
+var require2 = createRequire(import.meta.url);
+var packageMetadata = require2("../package.json");
+var packageVersion = getPackageVersion(packageMetadata);
+program.name("gz-cli-front").description("\u524D\u7AEF\u811A\u624B\u67B6\u5DE5\u5177").version(packageVersion);
+program.command("init [project-name]", { isDefault: true }).description("\u521B\u5EFA\u4E00\u4E2A\u65B0\u9879\u76EE").option("--pm <package-manager>", "\u6307\u5B9A\u5305\u7BA1\u7406\u5668\uFF1Anpm\u3001pnpm \u6216 yarn").option("--proxy <url>", "\u6307\u5B9A\u672C\u6B21\u521D\u59CB\u5316\u4F7F\u7528\u7684 HTTP(S) \u4EE3\u7406").option("--no-proxy", "\u5F3A\u5236\u76F4\u8FDE\uFF0C\u4E0D\u8BFB\u53D6\u73AF\u5883\u53D8\u91CF\u6216\u7CFB\u7EDF\u4EE3\u7406").option("--refresh", "\u5FFD\u7565\u6A21\u677F\u914D\u7F6E\u548C\u6A21\u677F\u7F13\u5B58\uFF0C\u5F3A\u5236\u4ECE\u8FDC\u7A0B\u4ED3\u5E93\u5237\u65B0").action((projectName, options) => {
+  void create(projectName, options);
+});
+program.command("create [project-name]").description("\u521B\u5EFA\u4E00\u4E2A\u65B0\u9879\u76EE\uFF08\u517C\u5BB9\u65E7\u547D\u4EE4\uFF09").option("--pm <package-manager>", "\u6307\u5B9A\u5305\u7BA1\u7406\u5668\uFF1Anpm\u3001pnpm \u6216 yarn").option("--proxy <url>", "\u6307\u5B9A\u672C\u6B21\u521D\u59CB\u5316\u4F7F\u7528\u7684 HTTP(S) \u4EE3\u7406").option("--no-proxy", "\u5F3A\u5236\u76F4\u8FDE\uFF0C\u4E0D\u8BFB\u53D6\u73AF\u5883\u53D8\u91CF\u6216\u7CFB\u7EDF\u4EE3\u7406").option("--refresh", "\u5FFD\u7565\u6A21\u677F\u914D\u7F6E\u548C\u6A21\u677F\u7F13\u5B58\uFF0C\u5F3A\u5236\u4ECE\u8FDC\u7A0B\u4ED3\u5E93\u5237\u65B0").action((projectName, options) => {
+  void create(projectName, options);
+});
+program.parse(process.argv);
+function getPackageVersion(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error("\u65E0\u6CD5\u8BFB\u53D6 gz-cli-front \u7248\u672C\u53F7\u3002");
+  }
+  const version = value.version;
+  if (typeof version !== "string" || !version.trim()) {
+    throw new Error("gz-cli-front package.json \u4E2D\u7F3A\u5C11\u6709\u6548\u7248\u672C\u53F7\u3002");
+  }
+  return version;
+}
+//# sourceMappingURL=index.js.map