@agile-team/jh4j-cloud-cli 0.3.0

package/dist/index.js

@@ -0,0 +1,1352 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "@agile-team/jh4j-cloud-cli",
+  version: "0.3.0",
+  description: "JH4J Cloud \u4F01\u4E1A\u5185\u90E8\u6807\u51C6\u5316\u9879\u76EE\u811A\u624B\u67B6",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ChenyCHENYU/jh4j-cloud-cli.git"
+  },
+  homepage: "https://github.com/ChenyCHENYU/jh4j-cloud-cli#readme",
+  bugs: {
+    url: "https://github.com/ChenyCHENYU/jh4j-cloud-cli/issues"
+  },
+  type: "module",
+  engines: {
+    node: "^22.12.0 || ^24.0.0",
+    pnpm: ">=11.8.0"
+  },
+  packageManager: "pnpm@11.8.0",
+  bin: {
+    jh4j: "bin/jh4j.js"
+  },
+  files: [
+    "bin",
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "catalog.schema.json"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    start: "node bin/jh4j.js",
+    check: "pnpm typecheck && pnpm test && pnpm build",
+    prepack: "pnpm check"
+  },
+  dependencies: {
+    "@clack/prompts": "^1.7.0",
+    commander: "^15.0.0",
+    semver: "^7.8.5",
+    tar: "^7.5.19"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  devDependencies: {
+    "@types/node": "^24.13.3",
+    "@types/semver": "7.7.1",
+    tsup: "8.5.1",
+    typescript: "7.0.2",
+    vitest: "4.1.10"
+  }
+};
+
+// src/constants.ts
+var CLI_NAME = "@agile-team/jh4j-cloud-cli";
+var CLI_VERSION = package_default.version;
+var COMMAND_NAME = "jh4j";
+var TEMPLATE_SOURCE_ENV = "JH4J_UI_TEMPLATE_SOURCE";
+var JH4J_HOME_ENV = "JH4J_HOME";
+var CATALOG_FILE_ENV = "JH4J_CATALOG_FILE";
+var USER_CONFIG_SCHEMA_VERSION = 1;
+
+// src/catalog.ts
+import { fileURLToPath } from "url";
+import path2 from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/utils/fs.ts
+import { cp, mkdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+var EXCLUDED_TEMPLATE_PATHS = /* @__PURE__ */ new Set([
+  ".git",
+  ".jhlc",
+  "dist",
+  "node_modules"
+]);
+async function readJson(file) {
+  return JSON.parse(await readFile(file, "utf8"));
+}
+async function writeJson(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function isDirectory(directory) {
+  try {
+    return (await stat(directory)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function isDirectoryEmpty(directory) {
+  if (!existsSync(directory)) return true;
+  const { readdir: readdir3 } = await import("fs/promises");
+  return (await readdir3(directory)).length === 0;
+}
+async function copyTemplateTree(sourceRoot, targetRoot) {
+  await mkdir(targetRoot, { recursive: true });
+  await cp(sourceRoot, targetRoot, {
+    recursive: true,
+    force: true,
+    filter(source) {
+      const relative = path.relative(sourceRoot, source);
+      if (!relative) return true;
+      const [topLevel] = relative.split(path.sep);
+      return !EXCLUDED_TEMPLATE_PATHS.has(topLevel);
+    }
+  });
+}
+async function removePath(target) {
+  await rm(target, { recursive: true, force: true, maxRetries: 3 });
+}
+
+// src/catalog.ts
+var siblingTemplatePath = fileURLToPath(
+  new URL("../../jh4j-ui-template/", import.meta.url)
+);
+var remoteTemplateSources = [
+  "https://github.com/ChenyCHENYU/jh4j-ui-template.git",
+  "https://gitee.com/ycyplus163/jh4j-ui-template.git"
+];
+var BUILTIN_TEMPLATES = [
+  {
+    id: "web.jh4j-mf-remote",
+    name: "JH4J PC \u5FAE\u524D\u7AEF\u4E1A\u52A1\u6A21\u677F",
+    description: "Vue 3 + Vite + Module Federation \u6807\u51C6\u4E1A\u52A1\u5B50\u7CFB\u7EDF",
+    category: "frontend",
+    sourceEnvironment: TEMPLATE_SOURCE_ENV,
+    defaultSource: existsSync2(siblingTemplatePath) ? siblingTemplatePath : remoteTemplateSources[0],
+    sources: remoteTemplateSources,
+    defaultRef: "main",
+    status: "beta",
+    tags: ["vue", "vite", "module-federation", "pc"]
+  }
+];
+function validateCatalogTemplate(template) {
+  if (!template.id || !template.name || !template.category) {
+    throw new Error("Catalog \u6A21\u677F\u7F3A\u5C11 id\u3001name \u6216 category");
+  }
+  if (!(/* @__PURE__ */ new Set(["frontend", "backend", "mobile"])).has(template.category)) {
+    throw new Error(`Catalog \u6A21\u677F ${template.id} \u7684 category \u65E0\u6548`);
+  }
+  if (!(/* @__PURE__ */ new Set(["stable", "beta"])).has(template.status)) {
+    throw new Error(`Catalog \u6A21\u677F ${template.id} \u7684 status \u65E0\u6548`);
+  }
+  if (!template.defaultRef) {
+    throw new Error(`Catalog \u6A21\u677F ${template.id} \u7F3A\u5C11 defaultRef`);
+  }
+  if (!template.defaultSource && !template.sourceEnvironment) {
+    throw new Error(`Catalog \u6A21\u677F ${template.id} \u6CA1\u6709\u53EF\u89E3\u6790\u7684\u6A21\u677F\u6E90`);
+  }
+  if (template.sources?.some((source) => !source.trim())) {
+    throw new Error(`Catalog \u6A21\u677F ${template.id} \u5305\u542B\u7A7A\u7684\u5907\u7528\u6E90`);
+  }
+}
+function resolveCatalogSource(source, catalogDirectory) {
+  const isRemote = /^(?:https?|ssh|file):\/\//.test(source) || source.startsWith("git@");
+  return isRemote || path2.isAbsolute(source) ? source : path2.resolve(catalogDirectory, source);
+}
+async function loadCatalog(config) {
+  const configuredFile = process.env[CATALOG_FILE_ENV] || config?.catalogFile;
+  if (!configuredFile) return [...BUILTIN_TEMPLATES];
+  const catalogPath = path2.resolve(configuredFile);
+  if (!existsSync2(catalogPath)) {
+    throw new Error(`Catalog \u6587\u4EF6\u4E0D\u5B58\u5728: ${catalogPath}`);
+  }
+  const external = await readJson(catalogPath);
+  if (external.schemaVersion !== 1 || !Array.isArray(external.templates)) {
+    throw new Error(`Catalog \u6587\u4EF6\u683C\u5F0F\u65E0\u6548: ${catalogPath}`);
+  }
+  const catalogDirectory = path2.dirname(catalogPath);
+  external.templates = external.templates.map((template) => {
+    return {
+      ...template,
+      defaultSource: resolveCatalogSource(
+        template.defaultSource,
+        catalogDirectory
+      ),
+      sources: template.sources?.map(
+        (source) => resolveCatalogSource(source, catalogDirectory)
+      )
+    };
+  });
+  external.templates.forEach(validateCatalogTemplate);
+  const merged = new Map(BUILTIN_TEMPLATES.map((item) => [item.id, item]));
+  external.templates.forEach((item) => merged.set(item.id, item));
+  return [...merged.values()];
+}
+function findTemplate(catalog, id) {
+  const selected = id ?? catalog[0]?.id;
+  const template = catalog.find((item) => item.id === selected);
+  if (!template) {
+    throw new Error(
+      `\u6A21\u677F\u4E0D\u5B58\u5728: ${selected}\u3002\u53EF\u7528\u6A21\u677F: ${catalog.map((item) => item.id).join(", ")}`
+    );
+  }
+  return template;
+}
+
+// src/core/template-source.ts
+import path5 from "path";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir3, readdir as readdir2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { x as extractTar } from "tar";
+
+// src/utils/process.ts
+import { spawn } from "child_process";
+function platformCommand(command) {
+  if (process.platform !== "win32") return command;
+  return command === "pnpm" || command === "npm" || command === "npx" ? `${command}.cmd` : command;
+}
+async function runCommand(command, args, options = {}) {
+  const stdio = options.stdio ?? "inherit";
+  return new Promise((resolve, reject) => {
+    const executable = platformCommand(command);
+    const isWindowsCommand = process.platform === "win32" && executable.endsWith(".cmd");
+    const spawnExecutable = isWindowsCommand ? process.env.ComSpec || "cmd.exe" : executable;
+    const spawnArgs = isWindowsCommand ? ["/d", "/s", "/c", executable, ...args] : args;
+    const child = spawn(spawnExecutable, spawnArgs, {
+      cwd: options.cwd,
+      stdio,
+      env: { ...process.env, ...options.env },
+      windowsHide: true
+    });
+    let output = "";
+    if (stdio === "pipe") {
+      child.stdout?.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+    }
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve(output.trim());
+        return;
+      }
+      reject(
+        new Error(
+          `${command} ${args.join(" ")} \u6267\u884C\u5931\u8D25\uFF08exit ${code ?? "unknown"}\uFF09${output ? `
+${output.trim()}` : ""}`
+        )
+      );
+    });
+  });
+}
+async function inspectCommand(command, args = ["--version"]) {
+  try {
+    return { ok: true, output: await runCommand(command, args, { stdio: "pipe" }) };
+  } catch (error) {
+    return { ok: false, output: error.message };
+  }
+}
+
+// src/core/template-cache.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, readdir, rename, stat as stat2 } from "fs/promises";
+import path4 from "path";
+
+// src/core/user-config.ts
+import os from "os";
+import path3 from "path";
+import { existsSync as existsSync3 } from "fs";
+var DEFAULT_USER_CONFIG = {
+  schemaVersion: USER_CONFIG_SCHEMA_VERSION,
+  autoInstall: true,
+  autoGit: true,
+  cacheTtlMinutes: 60
+};
+function getJh4jHome() {
+  return path3.resolve(process.env[JH4J_HOME_ENV] || path3.join(os.homedir(), ".jh4j"));
+}
+function getUserConfigPath() {
+  return path3.join(getJh4jHome(), "config.json");
+}
+async function loadUserConfig() {
+  const configPath = getUserConfigPath();
+  if (!existsSync3(configPath)) return { ...DEFAULT_USER_CONFIG };
+  const stored = await readJson(configPath);
+  if (stored.schemaVersion !== void 0 && stored.schemaVersion !== USER_CONFIG_SCHEMA_VERSION) {
+    throw new Error(
+      `\u4E0D\u652F\u6301\u7684\u7528\u6237\u914D\u7F6E\u7248\u672C: ${stored.schemaVersion}\uFF0C\u5F53\u524D\u8981\u6C42 ${USER_CONFIG_SCHEMA_VERSION}`
+    );
+  }
+  return { ...DEFAULT_USER_CONFIG, ...stored };
+}
+async function saveUserConfig(config) {
+  await writeJson(getUserConfigPath(), {
+    ...config,
+    schemaVersion: USER_CONFIG_SCHEMA_VERSION
+  });
+}
+var CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "catalogFile",
+  "templateSource",
+  "templateRef",
+  "npmRegistry",
+  "jhlcRegistry",
+  "autoInstall",
+  "autoGit",
+  "cacheTtlMinutes"
+]);
+function parseUserConfigValue(key, rawValue) {
+  if (!CONFIG_KEYS.has(key)) {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u914D\u7F6E\u9879: ${key}`);
+  }
+  const typedKey = key;
+  if (typedKey === "autoInstall" || typedKey === "autoGit") {
+    const normalized = rawValue.toLowerCase();
+    if (!(/* @__PURE__ */ new Set(["true", "false"])).has(normalized)) {
+      throw new Error(`${key} \u53EA\u80FD\u662F true \u6216 false`);
+    }
+    return [typedKey, normalized === "true"];
+  }
+  if (typedKey === "cacheTtlMinutes") {
+    const value = Number(rawValue);
+    if (!Number.isInteger(value) || value < 0 || value > 10080) {
+      throw new Error("cacheTtlMinutes \u5FC5\u987B\u662F 0 \u5230 10080 \u4E4B\u95F4\u7684\u6574\u6570");
+    }
+    return [typedKey, value];
+  }
+  return [typedKey, rawValue.trim()];
+}
+
+// src/core/template-cache.ts
+var CACHE_SCHEMA_VERSION = 1;
+function getTemplateCacheRoot() {
+  return path4.join(getJh4jHome(), "cache", "templates");
+}
+function getTemplateCacheKey(source, ref) {
+  return createHash("sha256").update(`${source}\0${ref}`).digest("hex").slice(0, 20);
+}
+function getEntryPaths(key) {
+  const entryRoot = path4.join(getTemplateCacheRoot(), key);
+  return {
+    entryRoot,
+    templateRoot: path4.join(entryRoot, "template"),
+    metadataPath: path4.join(entryRoot, "metadata.json")
+  };
+}
+async function readTemplateCacheEntry(source, ref) {
+  const key = getTemplateCacheKey(source, ref);
+  const paths = getEntryPaths(key);
+  if (!existsSync4(paths.templateRoot) || !existsSync4(paths.metadataPath)) return null;
+  try {
+    const metadata = await readJson(paths.metadataPath);
+    if (metadata.schemaVersion !== CACHE_SCHEMA_VERSION || metadata.source !== source || metadata.ref !== ref) {
+      return null;
+    }
+    return {
+      key,
+      root: paths.templateRoot,
+      metadata,
+      sizeBytes: await calculateDirectorySize(paths.entryRoot)
+    };
+  } catch {
+    return null;
+  }
+}
+function isTemplateCacheFresh(entry, ttlMinutes) {
+  if (ttlMinutes <= 0) return false;
+  const cachedAt = Date.parse(entry.metadata.cachedAt);
+  return Number.isFinite(cachedAt) && Date.now() - cachedAt < ttlMinutes * 6e4;
+}
+async function createTemplateCacheStaging(source, ref) {
+  const key = getTemplateCacheKey(source, ref);
+  const cacheRoot = getTemplateCacheRoot();
+  await mkdir2(cacheRoot, { recursive: true });
+  const stagingRoot = path4.join(
+    cacheRoot,
+    `.${key}.tmp-${process.pid}-${Date.now()}`
+  );
+  const templateRoot = path4.join(stagingRoot, "template");
+  const entryRoot = path4.join(cacheRoot, key);
+  await mkdir2(stagingRoot, { recursive: true });
+  return {
+    key,
+    entryRoot,
+    stagingRoot,
+    templateRoot,
+    async commit() {
+      await writeJson(path4.join(stagingRoot, "metadata.json"), {
+        schemaVersion: CACHE_SCHEMA_VERSION,
+        source,
+        ref,
+        cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await removePath(entryRoot);
+      await rename(stagingRoot, entryRoot);
+    },
+    cleanup: () => removePath(stagingRoot)
+  };
+}
+async function calculateDirectorySize(directory) {
+  let total = 0;
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolute = path4.join(directory, entry.name);
+    if (entry.isDirectory()) total += await calculateDirectorySize(absolute);
+    else if (entry.isFile()) total += (await stat2(absolute)).size;
+  }
+  return total;
+}
+async function listTemplateCache() {
+  const cacheRoot = getTemplateCacheRoot();
+  if (!existsSync4(cacheRoot)) return [];
+  const entries = [];
+  for (const directory of await readdir(cacheRoot, { withFileTypes: true })) {
+    if (!directory.isDirectory() || directory.name.startsWith(".")) continue;
+    const paths = getEntryPaths(directory.name);
+    if (!existsSync4(paths.metadataPath) || !existsSync4(paths.templateRoot)) continue;
+    try {
+      entries.push({
+        key: directory.name,
+        root: paths.templateRoot,
+        metadata: await readJson(paths.metadataPath),
+        sizeBytes: await calculateDirectorySize(paths.entryRoot)
+      });
+    } catch {
+    }
+  }
+  return entries.sort(
+    (a, b) => b.metadata.cachedAt.localeCompare(a.metadata.cachedAt)
+  );
+}
+async function clearTemplateCache() {
+  await removePath(getTemplateCacheRoot());
+}
+
+// src/core/template-source.ts
+var MAX_ARCHIVE_BYTES = 200 * 1024 * 1024;
+function resolveTemplateSources(template, override, configuredSource) {
+  const exclusiveSource = override || (template.sourceEnvironment ? process.env[template.sourceEnvironment] : void 0) || configuredSource;
+  if (exclusiveSource) return [exclusiveSource];
+  return [.../* @__PURE__ */ new Set([template.defaultSource, ...template.sources ?? []])];
+}
+function isGitSource(source) {
+  return source.startsWith("git@") || source.startsWith("ssh://") || source.startsWith("file://") || source.startsWith("http://") || source.startsWith("https://") || source.endsWith(".git");
+}
+function isArchiveSource(source) {
+  const pathname = source.split(/[?#]/, 1)[0].toLowerCase();
+  return pathname.endsWith(".tgz") || pathname.endsWith(".tar.gz") || pathname.endsWith(".tar");
+}
+async function getFreshCache(source, ref, options) {
+  const cacheEntry = await readTemplateCacheEntry(source, ref);
+  if (!options.noCache && cacheEntry && isTemplateCacheFresh(cacheEntry, options.cacheTtlMinutes ?? 60)) {
+    return {
+      root: cacheEntry.root,
+      source: `${source}#${ref} (cache)`,
+      async cleanup() {
+      }
+    };
+  }
+  return null;
+}
+async function normalizeExtractedTemplate(stagingRoot, templateRoot) {
+  if (existsSync5(path5.join(templateRoot, "template.manifest.json"))) return;
+  const children = await readdir2(templateRoot, { withFileTypes: true });
+  const candidates = children.filter(
+    (entry) => entry.isDirectory() && existsSync5(path5.join(templateRoot, entry.name, "template.manifest.json"))
+  );
+  if (candidates.length !== 1) {
+    throw new Error("\u538B\u7F29\u5305\u6839\u76EE\u5F55\u6216\u552F\u4E00\u4E00\u7EA7\u76EE\u5F55\u4E2D\u672A\u627E\u5230 template.manifest.json");
+  }
+  const normalizedRoot = path5.join(stagingRoot, ".normalized-template");
+  await rename2(path5.join(templateRoot, candidates[0].name), normalizedRoot);
+  await rm2(templateRoot, { recursive: true, force: true });
+  await rename2(normalizedRoot, templateRoot);
+}
+async function acquireArchiveTemplate(source, ref, options) {
+  const cached = await getFreshCache(source, ref, options);
+  if (cached) return cached;
+  const cacheStaging = await createTemplateCacheStaging(source, ref);
+  const archiveFile = path5.join(cacheStaging.stagingRoot, "template.tgz");
+  try {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      const response = await fetch(source, { signal: AbortSignal.timeout(6e4) });
+      if (!response.ok) {
+        throw new Error(`\u6A21\u677F\u538B\u7F29\u5305\u4E0B\u8F7D\u5931\u8D25: HTTP ${response.status}`);
+      }
+      const declaredLength = Number(response.headers.get("content-length") || 0);
+      if (declaredLength > MAX_ARCHIVE_BYTES) {
+        throw new Error("\u6A21\u677F\u538B\u7F29\u5305\u8D85\u8FC7 200 MB \u9650\u5236");
+      }
+      const archiveBuffer = Buffer.from(await response.arrayBuffer());
+      if (archiveBuffer.byteLength > MAX_ARCHIVE_BYTES) {
+        throw new Error("\u6A21\u677F\u538B\u7F29\u5305\u8D85\u8FC7 200 MB \u9650\u5236");
+      }
+      await writeFile2(archiveFile, archiveBuffer);
+    } else {
+      const { copyFile } = await import("fs/promises");
+      await copyFile(path5.resolve(source), archiveFile);
+    }
+    await mkdir3(cacheStaging.templateRoot, { recursive: true });
+    await extractTar({ file: archiveFile, cwd: cacheStaging.templateRoot });
+    await normalizeExtractedTemplate(
+      cacheStaging.stagingRoot,
+      cacheStaging.templateRoot
+    );
+    await rm2(archiveFile, { force: true });
+    await cacheStaging.commit();
+    return {
+      root: path5.join(cacheStaging.entryRoot, "template"),
+      source: `${source} (archive)`,
+      async cleanup() {
+      }
+    };
+  } catch (error) {
+    await cacheStaging.cleanup();
+    throw error;
+  }
+}
+async function acquireTemplate(source, ref, options = {}) {
+  const localPath = path5.resolve(source);
+  if (existsSync5(localPath)) {
+    if (await isDirectory(localPath)) {
+      return {
+        root: localPath,
+        source: localPath,
+        async cleanup() {
+        }
+      };
+    }
+    if (isArchiveSource(localPath)) {
+      return acquireArchiveTemplate(localPath, ref, options);
+    }
+    throw new Error(`\u6A21\u677F\u6E90\u4E0D\u662F\u76EE\u5F55\u6216\u652F\u6301\u7684 tar \u538B\u7F29\u5305: ${localPath}`);
+  }
+  if (isArchiveSource(source)) {
+    return acquireArchiveTemplate(source, ref, options);
+  }
+  if (!isGitSource(source)) {
+    throw new Error(`\u6A21\u677F\u6E90\u4E0D\u5B58\u5728: ${source}`);
+  }
+  const cached = await getFreshCache(source, ref, options);
+  if (cached) return cached;
+  const cacheStaging = await createTemplateCacheStaging(source, ref);
+  try {
+    await runCommand(
+      "git",
+      [
+        "-c",
+        "http.lowSpeedLimit=1024",
+        "-c",
+        "http.lowSpeedTime=15",
+        "clone",
+        "--depth",
+        "1",
+        "--branch",
+        ref,
+        source,
+        cacheStaging.templateRoot
+      ],
+      { stdio: "pipe", env: { GIT_TERMINAL_PROMPT: "0" } }
+    );
+    await cacheStaging.commit();
+    return {
+      root: path5.join(cacheStaging.entryRoot, "template"),
+      source: `${source}#${ref}`,
+      async cleanup() {
+      }
+    };
+  } catch (error) {
+    await cacheStaging.cleanup();
+    throw error;
+  }
+}
+async function acquireTemplateFromSources(sources, ref, options = {}) {
+  if (!sources.length) throw new Error("\u6CA1\u6709\u53EF\u7528\u7684\u6A21\u677F\u6E90");
+  const failures = [];
+  for (const source of [...new Set(sources)]) {
+    try {
+      return await acquireTemplate(source, ref, options);
+    } catch (error) {
+      failures.push(`${source}: ${error.message}`);
+    }
+  }
+  throw new Error(`\u6240\u6709\u6A21\u677F\u6E90\u5747\u4E0D\u53EF\u7528\uFF1A
+- ${failures.join("\n- ")}`);
+}
+
+// src/commands/create.ts
+import * as prompts2 from "@clack/prompts";
+
+// src/core/project-generator.ts
+import { existsSync as existsSync6 } from "fs";
+import { rename as rename3, rm as rm3 } from "fs/promises";
+import path7 from "path";
+import * as prompts from "@clack/prompts";
+import { satisfies } from "semver";
+
+// src/core/template-manifest.ts
+import path6 from "path";
+async function loadTemplateManifest(templateRoot) {
+  const manifest = await readJson(
+    path6.join(templateRoot, "template.manifest.json")
+  );
+  const errors = [];
+  if (manifest.schemaVersion !== 1) errors.push("schemaVersion \u5FC5\u987B\u4E3A 1");
+  if (!manifest.id) errors.push("\u7F3A\u5C11\u6A21\u677F id");
+  if (!manifest.name) errors.push("\u7F3A\u5C11\u6A21\u677F\u540D\u79F0");
+  if (!/^\d+\.\d+\.\d+([+-].+)?$/.test(manifest.version ?? "")) {
+    errors.push("\u6A21\u677F version \u4E0D\u662F\u6709\u6548\u7684\u8BED\u4E49\u5316\u7248\u672C");
+  }
+  if (!manifest.runtime?.node || !manifest.runtime?.packageManager) {
+    errors.push("\u7F3A\u5C11\u6A21\u677F\u8FD0\u884C\u65F6\u7EA6\u675F");
+  }
+  if (!manifest.entry?.nonInteractive) {
+    errors.push("\u7F3A\u5C11\u975E\u4EA4\u4E92\u521D\u59CB\u5316\u5165\u53E3");
+  }
+  const featureIds = /* @__PURE__ */ new Set();
+  for (const feature of manifest.features ?? []) {
+    if (!/^[a-z][a-z0-9-]*$/.test(feature.id)) {
+      errors.push(`\u6A21\u677F\u80FD\u529B id \u65E0\u6548: ${feature.id}`);
+    }
+    if (featureIds.has(feature.id)) {
+      errors.push(`\u6A21\u677F\u80FD\u529B id \u91CD\u590D: ${feature.id}`);
+    }
+    featureIds.add(feature.id);
+    if (!feature.name || !feature.description) {
+      errors.push(`\u6A21\u677F\u80FD\u529B ${feature.id} \u7F3A\u5C11\u540D\u79F0\u6216\u8BF4\u660E`);
+    }
+  }
+  if (errors.length) {
+    throw new Error(`\u6A21\u677F manifest \u65E0\u6548\uFF1A
+- ${errors.join("\n- ")}`);
+  }
+  return manifest;
+}
+
+// src/core/project-generator.ts
+var ENV_NAMES = ["dev", "sit", "uat", "pre", "prd"];
+function cancelled(value) {
+  return prompts.isCancel(value);
+}
+function ensureProjectName(value) {
+  const name = value.trim();
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(name)) {
+    throw new Error("\u9879\u76EE\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u548C\u8FDE\u5B57\u7B26");
+  }
+  return name;
+}
+function inferModuleName(projectName) {
+  const inferred = projectName.replace(/^(?:jh4j|wl)-ui-/, "").replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "");
+  return /^[a-z][a-z0-9-]*$/.test(inferred) ? inferred : "app";
+}
+function ensureModuleName(value) {
+  const name = value.trim();
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error("\u6A21\u5757\u6807\u8BC6\u5FC5\u987B\u4EE5\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u8FDE\u5B57\u7B26");
+  }
+  return name;
+}
+function ensurePort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1024 || port > 65535) {
+    throw new Error("\u5F00\u53D1\u7AEF\u53E3\u5FC5\u987B\u662F 1024 \u5230 65535 \u4E4B\u95F4\u7684\u6574\u6570");
+  }
+  return port;
+}
+function ensureHttpUrl(value, label) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error();
+    return value.replace(/\/+$/, "");
+  } catch {
+    throw new Error(`${label} \u5FC5\u987B\u662F http/https URL`);
+  }
+}
+async function askText(message, initialValue) {
+  const answer = await prompts.text({ message, initialValue });
+  if (cancelled(answer)) throw new Error("\u7528\u6237\u53D6\u6D88\u521B\u5EFA");
+  return String(answer).trim() || initialValue;
+}
+async function loadCreateConfig(configFile, cwd) {
+  if (!configFile) return {};
+  const resolved = path7.resolve(cwd, configFile);
+  if (!existsSync6(resolved)) throw new Error(`\u521B\u5EFA\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${resolved}`);
+  return readJson(resolved);
+}
+function parseFeatureIds(value) {
+  return [...new Set(value.split(",").map((item) => item.trim()).filter(Boolean))];
+}
+async function collectTemplateFeatures(manifest, fileConfig, options) {
+  const available = manifest.features ?? [];
+  if (!available.length) return [];
+  const knownIds = new Set(available.map((feature) => feature.id));
+  let selected = options.features ? parseFeatureIds(options.features) : Array.isArray(fileConfig.features) ? fileConfig.features : available.filter((feature) => feature.defaultEnabled || feature.required).map((feature) => feature.id);
+  const unknown = selected.filter((id) => !knownIds.has(id));
+  if (unknown.length) {
+    throw new Error(
+      `\u6A21\u677F\u4E0D\u652F\u6301\u4EE5\u4E0B\u80FD\u529B: ${unknown.join(", ")}\u3002\u53EF\u7528\u80FD\u529B: ${[...knownIds].join(", ")}`
+    );
+  }
+  if (options.standards === false) {
+    selected = selected.filter((id) => {
+      const feature = available.find((item) => item.id === id);
+      return feature?.package !== "@robot-admin/git-standards";
+    });
+  }
+  if (!options.yes) {
+    const selectable = available.filter(
+      (feature) => options.standards !== false || feature.package !== "@robot-admin/git-standards"
+    );
+    if (selectable.length) {
+      const answer = await prompts.multiselect({
+        message: "\u9009\u62E9\u9879\u76EE\u6807\u51C6\u5316\u80FD\u529B",
+        options: selectable.map((feature) => ({
+          value: feature.id,
+          label: feature.name,
+          hint: `${feature.description}${feature.package ? ` \xB7 ${feature.package}` : ""}`
+        })),
+        initialValues: selected,
+        required: false
+      });
+      if (cancelled(answer)) throw new Error("\u7528\u6237\u53D6\u6D88\u521B\u5EFA");
+      selected = answer.map(String);
+    }
+  }
+  for (const feature of available) {
+    if (feature.required && !selected.includes(feature.id)) {
+      selected.push(feature.id);
+    }
+  }
+  return selected;
+}
+async function collectProjectInput(projectName, sourceConfig, fileConfig, options, userConfig, features) {
+  let moduleName = options.module ?? fileConfig.moduleName ?? inferModuleName(projectName);
+  let title = options.title ?? fileConfig.title ?? sourceConfig.title;
+  let port = options.port ?? fileConfig.devServerPort ?? sourceConfig.devServerPort;
+  let npmRegistry = options.npmRegistry ?? fileConfig.npmRegistry ?? userConfig.npmRegistry ?? sourceConfig.npmRegistry;
+  let jhlcRegistry = options.jhlcRegistry ?? fileConfig.jhlcRegistry ?? userConfig.jhlcRegistry ?? sourceConfig.jhlcRegistry;
+  let localBackendUrl = options.localBackend ?? fileConfig.localBackendUrl ?? sourceConfig.localBackendUrl;
+  let localPublicUrl = options.localPublic ?? fileConfig.localPublicUrl ?? sourceConfig.localPublicUrl;
+  const environments = structuredClone(sourceConfig.environments);
+  for (const [env, value] of Object.entries(fileConfig.environments ?? {})) {
+    if (value && environments[env]) {
+      environments[env] = { ...environments[env], ...value };
+    }
+  }
+  if (!options.yes) {
+    moduleName = await askText("\u6A21\u5757\u6807\u8BC6", moduleName);
+    title = await askText("\u7CFB\u7EDF\u6807\u9898", title);
+    port = await askText("\u5F00\u53D1\u7AEF\u53E3", String(port));
+    npmRegistry = await askText("npm registry", npmRegistry);
+    jhlcRegistry = await askText("@jhlc \u79C1\u6709 registry", jhlcRegistry);
+    localBackendUrl = await askText("\u672C\u5730\u540E\u7AEF\u5730\u5740", localBackendUrl);
+    localPublicUrl = await askText("\u672C\u5730 public \u5730\u5740", localPublicUrl);
+    const configureEnvironments = await prompts.confirm({
+      message: "\u662F\u5426\u9010\u9879\u786E\u8BA4\u4E94\u5957\u73AF\u5883\u5730\u5740",
+      initialValue: false
+    });
+    if (cancelled(configureEnvironments)) throw new Error("\u7528\u6237\u53D6\u6D88\u521B\u5EFA");
+    if (configureEnvironments) {
+      for (const env of ENV_NAMES) {
+        environments[env].webUrl = await askText(
+          `${env.toUpperCase()} \u5E73\u53F0\u5730\u5740`,
+          environments[env].webUrl
+        );
+        environments[env].apiPrefix = await askText(
+          `${env.toUpperCase()} API \u524D\u7F00`,
+          environments[env].apiPrefix
+        );
+      }
+    }
+  }
+  if (!title.trim()) throw new Error("\u7CFB\u7EDF\u6807\u9898\u4E0D\u80FD\u4E3A\u7A7A");
+  for (const env of ENV_NAMES) {
+    if (!environments[env]) throw new Error(`\u7F3A\u5C11 ${env.toUpperCase()} \u73AF\u5883\u914D\u7F6E`);
+    environments[env] = {
+      webUrl: ensureHttpUrl(environments[env].webUrl, `${env.toUpperCase()} \u5E73\u53F0\u5730\u5740`),
+      apiPrefix: environments[env].apiPrefix.replace(/^\/+|\/+$/g, "")
+    };
+    if (!environments[env].apiPrefix) {
+      throw new Error(`${env.toUpperCase()} API \u524D\u7F00\u4E0D\u80FD\u4E3A\u7A7A`);
+    }
+  }
+  return {
+    projectName,
+    moduleName: ensureModuleName(moduleName),
+    title: title.trim(),
+    devServerPort: ensurePort(port),
+    npmRegistry: ensureHttpUrl(npmRegistry, "npm registry"),
+    jhlcRegistry: ensureHttpUrl(jhlcRegistry, "@jhlc \u79C1\u6709 registry"),
+    localBackendUrl: ensureHttpUrl(localBackendUrl, "\u672C\u5730\u540E\u7AEF\u5730\u5740"),
+    localPublicUrl: ensureHttpUrl(localPublicUrl, "\u672C\u5730 public \u5730\u5740"),
+    environments,
+    features
+  };
+}
+function assertSafeTarget(cwd, target) {
+  if (path7.dirname(target) !== cwd || target === cwd) {
+    throw new Error("\u4EC5\u5141\u8BB8\u5728\u5F53\u524D\u76EE\u5F55\u521B\u5EFA\u4E00\u7EA7\u9879\u76EE\u76EE\u5F55");
+  }
+}
+async function promoteStaging(stagingRoot, targetRoot, force) {
+  const targetExists = existsSync6(targetRoot);
+  if (!targetExists) {
+    await rename3(stagingRoot, targetRoot);
+    return;
+  }
+  if (!await isDirectoryEmpty(targetRoot) && !force) {
+    throw new Error(`\u76EE\u6807\u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A: ${targetRoot}`);
+  }
+  const backupRoot = `${targetRoot}.jh4j-backup-${Date.now()}`;
+  await rename3(targetRoot, backupRoot);
+  try {
+    await rename3(stagingRoot, targetRoot);
+  } catch (error) {
+    await rename3(backupRoot, targetRoot);
+    throw error;
+  }
+  try {
+    await removePath(backupRoot);
+  } catch {
+    prompts.log.warn(`\u65E7\u76EE\u5F55\u5907\u4EFD\u672A\u80FD\u81EA\u52A8\u6E05\u7406: ${backupRoot}`);
+  }
+}
+async function generateProject(catalogTemplate, requestedProjectName, options, cwd = process.cwd(), configuredUserConfig = DEFAULT_USER_CONFIG) {
+  const userConfig = { ...DEFAULT_USER_CONFIG, ...configuredUserConfig };
+  const projectName = ensureProjectName(requestedProjectName);
+  const resolvedCwd = path7.resolve(cwd);
+  const targetRoot = path7.resolve(resolvedCwd, projectName);
+  assertSafeTarget(resolvedCwd, targetRoot);
+  if (existsSync6(targetRoot) && !await isDirectoryEmpty(targetRoot) && !options.force) {
+    throw new Error(`\u76EE\u6807\u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A: ${targetRoot}`);
+  }
+  const ref = options.ref ?? userConfig.templateRef ?? catalogTemplate.defaultRef;
+  const sourceValues = resolveTemplateSources(
+    catalogTemplate,
+    options.source,
+    userConfig.templateSource
+  );
+  const acquired = await acquireTemplateFromSources(sourceValues, ref, {
+    noCache: options.cache === false,
+    cacheTtlMinutes: userConfig.cacheTtlMinutes
+  });
+  const stagingRoot = path7.join(
+    resolvedCwd,
+    `.${projectName}.jh4j-tmp-${process.pid}-${Date.now()}`
+  );
+  let promoted = false;
+  try {
+    const manifest = await loadTemplateManifest(acquired.root);
+    if (manifest.id !== catalogTemplate.id) {
+      throw new Error(
+        `\u6A21\u677F ID \u4E0D\u5339\u914D\uFF1ACatalog=${catalogTemplate.id}\uFF0CManifest=${manifest.id}`
+      );
+    }
+    if (!satisfies(process.versions.node, manifest.runtime.node)) {
+      throw new Error(
+        `\u5F53\u524D Node ${process.versions.node} \u4E0D\u6EE1\u8DB3\u6A21\u677F\u8981\u6C42 ${manifest.runtime.node}`
+      );
+    }
+    const sourceProjectConfig = await readJson(path7.join(acquired.root, "project.config.json"));
+    const fileConfig = await loadCreateConfig(options.config, resolvedCwd);
+    const features = await collectTemplateFeatures(manifest, fileConfig, options);
+    const input = await collectProjectInput(
+      projectName,
+      {
+        ...sourceProjectConfig,
+        npmRegistry: manifest.defaults.npmRegistry,
+        jhlcRegistry: manifest.defaults.jhlcRegistry
+      },
+      fileConfig,
+      options,
+      userConfig,
+      features
+    );
+    const shouldInstall = !options.skipInstall && userConfig.autoInstall;
+    const shouldInitializeGit = !options.skipGit && userConfig.autoGit;
+    if (options.dryRun) {
+      prompts.note(
+        [
+          `\u6A21\u677F: ${manifest.id}@${manifest.version}`,
+          `\u6765\u6E90: ${acquired.source}`,
+          `\u76EE\u6807: ${targetRoot}`,
+          `\u6A21\u5757: ${input.moduleName}`,
+          `\u7AEF\u53E3: ${input.devServerPort}`,
+          `\u80FD\u529B: ${input.features.length ? input.features.join(", ") : "\u65E0\u53EF\u9009\u80FD\u529B"}`,
+          `\u5B89\u88C5\u4F9D\u8D56: ${shouldInstall ? "\u662F" : "\u5426"}`,
+          `\u521D\u59CB\u5316 Git: ${shouldInitializeGit ? "\u662F" : "\u5426"}`
+        ].join("\n"),
+        "Dry Run"
+      );
+      return {
+        targetRoot,
+        templateId: manifest.id,
+        templateVersion: manifest.version,
+        source: acquired.source,
+        features: input.features,
+        installed: false,
+        gitInitialized: false
+      };
+    }
+    await copyTemplateTree(acquired.root, stagingRoot);
+    const inputFile = path7.join(stagingRoot, ".jh4j-cli-input.json");
+    await writeJson(inputFile, input);
+    try {
+      await runCommand(
+        process.execPath,
+        [
+          path7.join(stagingRoot, "scripts", "setup-project.mjs"),
+          "--yes",
+          "--config",
+          inputFile,
+          "--created-by",
+          `${CLI_NAME}@${CLI_VERSION}`
+        ],
+        { cwd: stagingRoot, stdio: "pipe" }
+      );
+    } finally {
+      await rm3(inputFile, { force: true });
+    }
+    if (!existsSync6(path7.join(stagingRoot, manifest.generatedMetadata))) {
+      throw new Error(`\u6A21\u677F\u521D\u59CB\u5316\u672A\u751F\u6210\u5143\u6570\u636E: ${manifest.generatedMetadata}`);
+    }
+    await promoteStaging(stagingRoot, targetRoot, Boolean(options.force));
+    promoted = true;
+    let gitInitialized = false;
+    if (shouldInitializeGit) {
+      await runCommand("git", ["init", "-b", "main"], {
+        cwd: targetRoot,
+        stdio: "pipe"
+      });
+      gitInitialized = true;
+    }
+    if (shouldInstall) {
+      try {
+        await runCommand("pnpm", ["install"], { cwd: targetRoot });
+      } catch (error) {
+        throw new Error(
+          `\u9879\u76EE\u5DF2\u751F\u6210\uFF0C\u4F46\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF1B\u76EE\u5F55\u5DF2\u4FDD\u7559\u5728 ${targetRoot}
+${error.message}`
+        );
+      }
+    }
+    if (shouldInitializeGit) {
+      await runCommand("git", ["add", "-A"], { cwd: targetRoot, stdio: "pipe" });
+      try {
+        await runCommand(
+          "git",
+          ["commit", "-m", `feat(init): \u57FA\u4E8E ${manifest.id}@${manifest.version} \u521D\u59CB\u5316`],
+          {
+            cwd: targetRoot,
+            stdio: "pipe",
+            env: { HUSKY: "0" }
+          }
+        );
+      } catch (error) {
+        prompts.log.warn(`Git \u5DF2\u521D\u59CB\u5316\uFF0C\u4F46\u521D\u59CB\u63D0\u4EA4\u672A\u5B8C\u6210\uFF1A${error.message}`);
+      }
+    }
+    return {
+      targetRoot,
+      templateId: manifest.id,
+      templateVersion: manifest.version,
+      source: acquired.source,
+      features: input.features,
+      installed: shouldInstall,
+      gitInitialized
+    };
+  } finally {
+    if (!promoted && existsSync6(stagingRoot)) await removePath(stagingRoot);
+    await acquired.cleanup();
+  }
+}
+
+// src/commands/create.ts
+var CATEGORY_OPTIONS = [
+  { value: "frontend", label: "\u524D\u7AEF", hint: "PC\u3001Web \u4E0E\u5FAE\u524D\u7AEF\u5E94\u7528" },
+  { value: "backend", label: "\u540E\u7AEF", hint: "Java \u670D\u52A1\u4E0E\u4E91\u539F\u751F\u5E94\u7528" },
+  { value: "mobile", label: "\u79FB\u52A8\u7AEF", hint: "App\u3001H5 \u4E0E\u8DE8\u7AEF\u5E94\u7528" }
+];
+function isCategory(value) {
+  return CATEGORY_OPTIONS.some((item) => item.value === value);
+}
+function templatesByCategory(templates, category) {
+  return templates.filter((template) => template.category === category);
+}
+async function selectCategory(templates, requestedCategory, nonInteractive) {
+  if (requestedCategory) {
+    if (!isCategory(requestedCategory)) {
+      throw new Error(
+        `\u9879\u76EE\u7C7B\u578B\u65E0\u6548: ${requestedCategory}\u3002\u53EF\u7528\u503C: frontend\u3001backend\u3001mobile`
+      );
+    }
+    if (!templatesByCategory(templates, requestedCategory).length) {
+      throw new Error(`\u9879\u76EE\u7C7B\u578B ${requestedCategory} \u6682\u65E0\u53EF\u7528\u6A21\u677F`);
+    }
+    return requestedCategory;
+  }
+  const firstAvailable = CATEGORY_OPTIONS.find(
+    (item) => templatesByCategory(templates, item.value).length > 0
+  );
+  if (!firstAvailable) throw new Error("Catalog \u4E2D\u6CA1\u6709\u53EF\u7528\u6A21\u677F");
+  if (nonInteractive) return firstAvailable.value;
+  const selected = await prompts2.select({
+    message: "\u9009\u62E9\u9879\u76EE\u7C7B\u578B",
+    options: CATEGORY_OPTIONS.map((item) => {
+      const count = templatesByCategory(templates, item.value).length;
+      return {
+        value: item.value,
+        label: item.label,
+        hint: count ? `${item.hint} \xB7 ${count} \u4E2A\u6A21\u677F` : `${item.hint} \xB7 \u6682\u672A\u63D0\u4F9B`,
+        disabled: count === 0
+      };
+    })
+  });
+  if (prompts2.isCancel(selected)) throw new Error("\u7528\u6237\u53D6\u6D88\u521B\u5EFA");
+  return selected;
+}
+async function selectTemplate(templates, options) {
+  if (options.template) {
+    const selected2 = findTemplate(templates, options.template);
+    if (options.category && selected2.category !== options.category) {
+      throw new Error(
+        `\u6A21\u677F ${selected2.id} \u5C5E\u4E8E ${selected2.category}\uFF0C\u4E0E --category ${options.category} \u4E0D\u4E00\u81F4`
+      );
+    }
+    return selected2;
+  }
+  const category = await selectCategory(
+    templates,
+    options.category,
+    Boolean(options.yes)
+  );
+  const candidates = templatesByCategory(templates, category);
+  if (options.yes) return findTemplate(candidates);
+  const selected = await prompts2.select({
+    message: "\u9009\u62E9\u9879\u76EE\u6A21\u677F",
+    options: candidates.map((template) => ({
+      value: template.id,
+      label: template.name,
+      hint: `${template.status} \xB7 ${template.description}`
+    }))
+  });
+  if (prompts2.isCancel(selected)) throw new Error("\u7528\u6237\u53D6\u6D88\u521B\u5EFA");
+  return findTemplate(candidates, String(selected));
+}
+async function createCommand(requestedName, options) {
+  prompts2.intro("JH4J Cloud \u9879\u76EE\u521B\u5EFA");
+  const userConfig = await loadUserConfig();
+  const catalog = await loadCatalog(userConfig);
+  let projectName = requestedName;
+  if (!projectName) {
+    if (options.yes) throw new Error("\u975E\u4EA4\u4E92\u6A21\u5F0F\u5FC5\u987B\u6307\u5B9A\u9879\u76EE\u540D\u79F0");
+    const answer = await prompts2.text({
+      message: "\u9879\u76EE\u540D\u79F0",
+      placeholder: "jh4j-ui-app"
+    });
+    if (prompts2.isCancel(answer)) throw new Error("\u7528\u6237\u53D6\u6D88\u521B\u5EFA");
+    projectName = String(answer);
+  }
+  const template = await selectTemplate(catalog, options);
+  const result = await generateProject(
+    template,
+    projectName,
+    options,
+    process.cwd(),
+    userConfig
+  );
+  if (options.dryRun) {
+    prompts2.outro("Dry Run \u5B8C\u6210\uFF0C\u672A\u5199\u5165\u4EFB\u4F55\u9879\u76EE\u6587\u4EF6");
+    return;
+  }
+  prompts2.note(
+    [
+      `\u76EE\u5F55: ${result.targetRoot}`,
+      `\u6A21\u677F: ${result.templateId}@${result.templateVersion}`,
+      `\u6765\u6E90: ${result.source}`,
+      `\u80FD\u529B: ${result.features.length ? result.features.join(", ") : "\u65E0\u53EF\u9009\u80FD\u529B"}`,
+      `\u4F9D\u8D56: ${result.installed ? "\u5DF2\u5B89\u88C5" : "\u672A\u5B89\u88C5"}`,
+      `Git: ${result.gitInitialized ? "main \u5DF2\u521D\u59CB\u5316" : "\u672A\u521D\u59CB\u5316"}`,
+      "",
+      `cd ${projectName}`,
+      ...!result.installed ? ["pnpm install"] : [],
+      "pnpm dev"
+    ].join("\n"),
+    "\u521B\u5EFA\u6210\u529F"
+  );
+  prompts2.outro("Happy coding!");
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir4, writeFile as writeFile3, rm as rm4 } from "fs/promises";
+import path8 from "path";
+import { coerce, gte, satisfies as satisfies2 } from "semver";
+async function checkHomeWritable() {
+  const home = getJh4jHome();
+  const probe = path8.join(home, `.write-probe-${process.pid}`);
+  try {
+    await mkdir4(home, { recursive: true });
+    await writeFile3(probe, "ok", "utf8");
+    await rm4(probe, { force: true });
+    return { name: "JH4J_HOME", ok: true, detail: home };
+  } catch (error) {
+    return { name: "JH4J_HOME", ok: false, detail: error.message };
+  }
+}
+async function collectDoctorChecks(suppliedConfig, suppliedCatalog) {
+  const config = suppliedConfig ?? await loadUserConfig();
+  const catalog = suppliedCatalog ?? await loadCatalog(config);
+  const [git, pnpm, home] = await Promise.all([
+    inspectCommand("git"),
+    inspectCommand("pnpm"),
+    checkHomeWritable()
+  ]);
+  const pnpmVersion = coerce(pnpm.output)?.version;
+  const checks = [
+    {
+      name: "Node.js",
+      ok: satisfies2(process.versions.node, "^22.12.0 || ^24.0.0"),
+      detail: `${process.versions.node}\uFF08\u8981\u6C42 Node 22.12+ \u6216 24.x\uFF09`
+    },
+    { name: "Git", ok: git.ok, detail: git.output },
+    {
+      name: "pnpm",
+      ok: pnpm.ok && Boolean(pnpmVersion && gte(pnpmVersion, "11.8.0")),
+      detail: pnpm.output
+    },
+    home
+  ];
+  for (const template of catalog) {
+    const sources = resolveTemplateSources(
+      template,
+      void 0,
+      config.templateSource
+    );
+    const source = sources[0];
+    if (!existsSync7(source)) {
+      checks.push({
+        name: `\u6A21\u677F ${template.id}`,
+        ok: source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@"),
+        detail: `\u8FDC\u7A0B\u5019\u9009\u6E90\uFF08\u521B\u5EFA\u65F6\u4F9D\u6B21\u9A8C\u8BC1\uFF09: ${sources.join(" \u2192 ")}`
+      });
+      continue;
+    }
+    try {
+      const manifest = await loadTemplateManifest(source);
+      checks.push({
+        name: `\u6A21\u677F ${template.id}`,
+        ok: manifest.id === template.id && satisfies2(process.versions.node, manifest.runtime.node),
+        detail: `${manifest.id}@${manifest.version} (${source})`
+      });
+    } catch (error) {
+      checks.push({
+        name: `\u6A21\u677F ${template.id}`,
+        ok: false,
+        detail: error.message
+      });
+    }
+  }
+  return checks;
+}
+async function doctorCommand(options = {}) {
+  const checks = await collectDoctorChecks();
+  const failed = checks.filter((check) => !check.ok);
+  if (options.json) {
+    console.log(JSON.stringify({ ok: failed.length === 0, checks }, null, 2));
+  } else {
+    for (const check of checks) {
+      console.log(`${check.ok ? "\u2713" : "\u2717"} ${check.name}: ${check.detail}`);
+    }
+    console.log(`
+\u7ED3\u679C: ${checks.length - failed.length} \u901A\u8FC7, ${failed.length} \u5931\u8D25`);
+  }
+  if (failed.length) process.exitCode = 1;
+}
+
+// src/commands/info.ts
+import path9 from "path";
+import { existsSync as existsSync8 } from "fs";
+async function infoCommand(projectPath = process.cwd(), options = {}) {
+  const root = path9.resolve(projectPath);
+  const metadataPath = path9.join(root, ".jhlc", "project.json");
+  if (!existsSync8(metadataPath)) {
+    throw new Error(`\u5F53\u524D\u76EE\u5F55\u4E0D\u662F JH4J CLI \u521B\u5EFA\u7684\u9879\u76EE: ${metadataPath}`);
+  }
+  const metadata = await readJson(metadataPath);
+  if (options.json) {
+    console.log(JSON.stringify({ projectRoot: root, ...metadata }, null, 2));
+    return;
+  }
+  console.log(`\u9879\u76EE\u76EE\u5F55: ${root}`);
+  console.log(`\u6A21\u677F: ${metadata.template.id}@${metadata.template.version}`);
+  console.log(`\u5E73\u53F0\u7248\u672C: ${metadata.platformVersion ?? "\u672A\u58F0\u660E"}`);
+  console.log(`\u521B\u5EFA\u65F6\u95F4: ${metadata.createdAt}`);
+  console.log(`\u521B\u5EFA\u5DE5\u5177: ${metadata.createdBy}`);
+  console.log("\u9879\u76EE\u53C2\u6570:");
+  console.log(JSON.stringify(metadata.parameters, null, 2));
+}
+
+// src/commands/list.ts
+async function listCommand(options = {}) {
+  const templates = await loadCatalog(await loadUserConfig());
+  if (options.json) {
+    console.log(JSON.stringify(templates, null, 2));
+    return;
+  }
+  console.table(
+    templates.map((template) => ({
+      ID: template.id,
+      \u540D\u79F0: template.name,
+      \u7C7B\u578B: template.category,
+      \u72B6\u6001: template.status,
+      \u9ED8\u8BA4\u5206\u652F: template.defaultRef,
+      \u6807\u7B7E: template.tags?.join(", ") ?? ""
+    }))
+  );
+}
+
+// src/commands/template.ts
+import path10 from "path";
+async function validateTemplateCommand(templatePath) {
+  const root = path10.resolve(templatePath);
+  const manifest = await loadTemplateManifest(root);
+  await runCommand(process.execPath, [path10.join(root, "scripts", "validate-template.mjs")], {
+    cwd: root
+  });
+  console.log(`\u6A21\u677F\u53EF\u7528: ${manifest.id}@${manifest.version}`);
+}
+
+// src/commands/config.ts
+async function configListCommand(options = {}) {
+  const config = await loadUserConfig();
+  if (options.json) console.log(JSON.stringify(config, null, 2));
+  else console.table(Object.entries(config).map(([key, value]) => ({ key, value })));
+  console.log(`\u914D\u7F6E\u6587\u4EF6: ${getUserConfigPath()}`);
+}
+async function configGetCommand(key) {
+  const config = await loadUserConfig();
+  if (!(key in config)) throw new Error(`\u914D\u7F6E\u9879\u4E0D\u5B58\u5728: ${key}`);
+  console.log(String(config[key]));
+}
+async function configSetCommand(key, value) {
+  const config = await loadUserConfig();
+  const [typedKey, typedValue] = parseUserConfigValue(key, value);
+  config[typedKey] = typedValue;
+  await saveUserConfig(config);
+  console.log(`\u5DF2\u8BBE\u7F6E ${typedKey}=${String(typedValue)}`);
+}
+async function configUnsetCommand(key) {
+  const config = await loadUserConfig();
+  if (!(key in DEFAULT_USER_CONFIG) && !(key in config)) {
+    throw new Error(`\u914D\u7F6E\u9879\u4E0D\u5B58\u5728: ${key}`);
+  }
+  const defaults = DEFAULT_USER_CONFIG;
+  const mutable = config;
+  if (key in defaults) mutable[key] = defaults[key];
+  else delete mutable[key];
+  await saveUserConfig(config);
+  console.log(`\u5DF2\u91CD\u7F6E\u914D\u7F6E\u9879: ${key}`);
+}
+async function configResetCommand() {
+  await saveUserConfig({ ...DEFAULT_USER_CONFIG });
+  console.log(`\u7528\u6237\u914D\u7F6E\u5DF2\u6062\u590D\u9ED8\u8BA4\u503C: ${getUserConfigPath()}`);
+}
+
+// src/commands/cache.ts
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 ** 2) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 ** 2).toFixed(1)} MB`;
+}
+async function cacheListCommand(options = {}) {
+  const entries = await listTemplateCache();
+  if (options.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  if (!entries.length) {
+    console.log(`\u6A21\u677F\u7F13\u5B58\u4E3A\u7A7A: ${getTemplateCacheRoot()}`);
+    return;
+  }
+  console.table(
+    entries.map((entry) => ({
+      Key: entry.key,
+      \u6765\u6E90: entry.metadata.source,
+      Ref: entry.metadata.ref,
+      \u7F13\u5B58\u65F6\u95F4: entry.metadata.cachedAt,
+      \u5927\u5C0F: formatBytes(entry.sizeBytes)
+    }))
+  );
+}
+async function cacheClearCommand() {
+  await clearTemplateCache();
+  console.log(`\u6A21\u677F\u7F13\u5B58\u5DF2\u6E05\u7406: ${getTemplateCacheRoot()}`);
+}
+
+// src/cli.ts
+function createProgram() {
+  const program = new Command();
+  program.name(COMMAND_NAME).description("JH4J Cloud \u4F01\u4E1A\u5185\u90E8\u6807\u51C6\u5316\u9879\u76EE\u811A\u624B\u67B6").version(CLI_VERSION);
+  program.command("create [name]").description("\u6839\u636E\u6807\u51C6\u6A21\u677F\u521B\u5EFA\u9879\u76EE").option("-c, --category <category>", "\u9879\u76EE\u7C7B\u578B\uFF1Afrontend\u3001backend \u6216 mobile").option("-t, --template <id>", "\u6A21\u677F ID").option("--features <ids>", "\u542F\u7528\u7684\u6A21\u677F\u80FD\u529B\uFF0C\u591A\u4E2A ID \u4F7F\u7528\u9017\u53F7\u5206\u9694").option("--no-standards", "\u4E0D\u542F\u7528\u6A21\u677F\u63D0\u4F9B\u7684 Git/\u4EE3\u7801\u6807\u51C6\u5316\u80FD\u529B").option("--source <path-or-url>", "\u8986\u76D6\u6A21\u677F\u6E90\uFF08\u672C\u5730\u76EE\u5F55\u6216 Git URL\uFF09").option("--ref <branch-or-tag>", "Git \u5206\u652F\u6216\u6807\u7B7E", "main").option("--module <name>", "\u5E73\u53F0\u6A21\u5757\u6807\u8BC6").option("--title <title>", "\u7CFB\u7EDF\u6807\u9898").option("--port <port>", "\u5F00\u53D1\u7AEF\u53E3").option("--npm-registry <url>", "npm registry\uFF08\u9700\u5305\u542B\u4F01\u4E1A\u5B9A\u5236\u5305\uFF09").option("--jhlc-registry <url>", "@jhlc \u79C1\u6709 registry").option("--local-backend <url>", "\u672C\u5730\u540E\u7AEF\u5730\u5740").option("--local-public <url>", "\u672C\u5730 public \u5730\u5740").option("--config <json-file>", "\u4ECE JSON \u6587\u4EF6\u8BFB\u53D6\u521B\u5EFA\u53C2\u6570").option("-y, --yes", "\u63A5\u53D7\u6A21\u677F\u9ED8\u8BA4\u503C\uFF0C\u975E\u4EA4\u4E92\u521B\u5EFA").option("--dry-run", "\u53EA\u9884\u89C8\uFF0C\u4E0D\u5199\u5165\u6587\u4EF6").option("--skip-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--skip-git", "\u8DF3\u8FC7 Git \u521D\u59CB\u5316").option("--force", "\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u540C\u540D\u76EE\u5F55").option("--no-cache", "\u4E0D\u4F7F\u7528\u5DF2\u6709\u8FDC\u7A0B\u6A21\u677F\u7F13\u5B58").action(createCommand);
+  program.command("list").description("\u5217\u51FA\u53EF\u7528\u6A21\u677F").option("--json", "\u8F93\u51FA JSON").action(listCommand);
+  program.command("doctor").description("\u68C0\u67E5\u672C\u673A\u73AF\u5883\u548C\u6A21\u677F\u53EF\u7528\u6027").option("--json", "\u8F93\u51FA JSON").action(doctorCommand);
+  program.command("info [path]").description("\u663E\u793A\u5DF2\u751F\u6210\u9879\u76EE\u7684\u6A21\u677F\u4E0E\u7248\u672C\u4FE1\u606F").option("--json", "\u8F93\u51FA JSON").action(infoCommand);
+  const template = program.command("template").description("\u6A21\u677F\u7EF4\u62A4\u547D\u4EE4");
+  template.command("validate [path]").description("\u6821\u9A8C\u6A21\u677F manifest \u4E0E\u6A21\u677F\u5951\u7EA6").action(async (templatePath) => {
+    if (templatePath) return validateTemplateCommand(templatePath);
+    const config2 = await loadUserConfig();
+    const selected = findTemplate(await loadCatalog(config2));
+    const acquired = await acquireTemplateFromSources(
+      resolveTemplateSources(selected, void 0, config2.templateSource),
+      config2.templateRef ?? selected.defaultRef,
+      { cacheTtlMinutes: config2.cacheTtlMinutes }
+    );
+    try {
+      return await validateTemplateCommand(acquired.root);
+    } finally {
+      await acquired.cleanup();
+    }
+  });
+  const config = program.command("config").description("\u7BA1\u7406\u7528\u6237\u9ED8\u8BA4\u914D\u7F6E");
+  config.command("list").option("--json", "\u8F93\u51FA JSON").action(configListCommand);
+  config.command("get <key>").action(configGetCommand);
+  config.command("set <key> <value>").action(configSetCommand);
+  config.command("unset <key>").action(configUnsetCommand);
+  config.command("reset").action(configResetCommand);
+  const cache = program.command("cache").description("\u7BA1\u7406\u8FDC\u7A0B\u6A21\u677F\u7F13\u5B58");
+  cache.command("list").option("--json", "\u8F93\u51FA JSON").action(cacheListCommand);
+  cache.command("clear").action(cacheClearCommand);
+  return program;
+}
+async function runCli(argv = process.argv) {
+  await createProgram().parseAsync(argv);
+}
+
+// src/index.ts
+runCli().catch((error) => {
+  console.error(`
+\u9519\u8BEF: ${error.message}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map