listpage_cli 0.0.293 → 0.0.294

package/bin/prompts.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrompt = runPrompt;
 exports.askRushQuestions = askRushQuestions;
 exports.askProjectPath = askProjectPath;
 exports.askOverwrite = askOverwrite;
@@ -12,60 +13,148 @@ exports.printVersion = printVersion;
 const enquirer_1 = require("enquirer");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
+const interaction_result_1 = require("./domain/interaction-result");
+let promptTestScript = null;
+let promptTestScriptIndex = 0;
+function getTestPromptMode() {
+    const mode = process.env.LISTPAGE_CLI_PROMPT_TEST_MODE;
+    if (mode === "cancel" || mode === "invalid") {
+        return mode;
+    }
+    return undefined;
+}
+function getNextScriptedPromptResult() {
+    if (promptTestScript === null) {
+        const raw = process.env.LISTPAGE_CLI_PROMPT_TEST_SCRIPT;
+        if (!raw) {
+            promptTestScript = [];
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                promptTestScript = parsed;
+            }
+            else {
+                promptTestScript = [];
+            }
+        }
+        catch {
+            promptTestScript = [];
+        }
+    }
+    const next = promptTestScript[promptTestScriptIndex];
+    promptTestScriptIndex += 1;
+    return next;
+}
+function isCancelError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const normalized = error.message.toLowerCase();
+    return (normalized.includes("cancel") ||
+        normalized.includes("aborted") ||
+        normalized.includes("interrupted"));
+}
+async function runPrompt(options, runner = enquirer_1.prompt) {
+    const testMode = getTestPromptMode();
+    if (testMode === "cancel") {
+        return (0, interaction_result_1.interactionCancelled)();
+    }
+    if (testMode === "invalid") {
+        return (0, interaction_result_1.interactionInvalid)("测试模式: 模拟无效输入");
+    }
+    const scripted = getNextScriptedPromptResult();
+    if (scripted !== undefined) {
+        if (scripted === "cancel") {
+            return (0, interaction_result_1.interactionCancelled)();
+        }
+        if (scripted === "invalid") {
+            return (0, interaction_result_1.interactionInvalid)("测试脚本: 模拟无效输入");
+        }
+        return (0, interaction_result_1.interactionValue)(scripted);
+    }
+    try {
+        const value = (await runner(options));
+        return (0, interaction_result_1.interactionValue)(value);
+    }
+    catch (error) {
+        if (isCancelError(error)) {
+            return (0, interaction_result_1.interactionCancelled)();
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        return (0, interaction_result_1.interactionInvalid)(reason);
+    }
+}
 async function askRushQuestions() {
-    const { name: frontendName } = await (0, enquirer_1.prompt)({
+    const frontend = await runPrompt({
         type: "input",
         name: "name",
         message: "请输入前端项目名称，为空表示不创建前端项目",
         initial: "",
     });
-    const { name: backendName } = await (0, enquirer_1.prompt)({
+    if (frontend.status !== "value") {
+        return frontend;
+    }
+    const backend = await runPrompt({
         type: "input",
         name: "name",
         message: "请输入后端项目名称，为空表示不创建后端项目",
         initial: "",
     });
-    return { frontendName, backendName };
+    if (backend.status !== "value") {
+        return backend;
+    }
+    return (0, interaction_result_1.interactionValue)({
+        frontendName: frontend.value.name,
+        backendName: backend.value.name,
+    });
 }
 async function askProjectPath() {
-    const ans = await (0, enquirer_1.prompt)({
+    const result = await runPrompt({
         type: "input",
         name: "path",
         message: "请填写项目名称或路径，如果填.表示直接把项目放到当前目录下",
         initial: ".",
     });
-    const p = (ans.path || ".").trim();
-    return p || ".";
+    if (result.status !== "value") {
+        return result;
+    }
+    const p = (result.value.path || ".").trim();
+    return (0, interaction_result_1.interactionValue)(p || ".");
 }
 async function askOverwrite() {
-    const { ok } = await (0, enquirer_1.prompt)({
+    const result = await runPrompt({
         type: "confirm",
         name: "ok",
         message: "目标目录非空，是否覆盖？",
         initial: false,
     });
-    if (!ok) {
-        console.error("已取消");
-        process.exit(1);
+    if (result.status !== "value") {
+        return result;
     }
+    return (0, interaction_result_1.interactionValue)(result.value.ok);
 }
 async function askInstallDeployScript() {
-    const { ok } = await (0, enquirer_1.prompt)({
+    const result = await runPrompt({
         type: "confirm",
         name: "ok",
         message: "是否添加部署脚本？这个脚本允许你可以帮你快速构建docker镜像，并发布到阿里云等环境，但是需要本机有docker环境。",
         initial: false,
     });
-    return ok;
+    if (result.status !== "value") {
+        return result;
+    }
+    return (0, interaction_result_1.interactionValue)(result.value.ok);
 }
 function printHelp() {
     const h = [
         "用法: listpage_cli init",
         "说明: 进入中文引导式交互，按提示填写即可",
-        "用法: listpage_cli sync-docs",
-        "说明: 将模板中的 .trae 和 docs 同步到执行目录的同级目录",
-        "用法: listpage_cli install-skill [listpage] [--project]",
-        "说明: 安装 listpage 技能到 Cursor。默认安装到 ~/.cursor/skills/；加 --project 则安装到当前项目 .cursor/skills/",
+        "用法: listpage_cli install-skill [skillName] [--project]",
+        "说明: 安装技能到 Cursor。默认 skillName 为 test，安装到当前命令执行目录的 .cursor/skills/",
+        "用法: listpage_cli build-project",
+        "说明: 非交互校验当前目录是否为有效项目根（需存在 listpage.config.json）",
     ].join("\n");
     console.log(h);
 }

package/bin/services/artifact-validator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/services/build-project-service.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBuildProjectFlow = runBuildProjectFlow;
+const command_result_1 = require("../domain/command-result");
+const config_loader_1 = require("./config-loader");
+const command_runner_1 = require("./command-runner");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const CONFIG_ERROR_CODE_MAP = {
+    CONFIG_NOT_FOUND: "E_CONFIG_NOT_FOUND",
+    CONFIG_READ_FAILED: "E_CONFIG_READ_FAILED",
+    CONFIG_INVALID_JSON: "E_CONFIG_INVALID_JSON",
+    CONFIG_REQUIRED_FIELD_MISSING: "E_CONFIG_REQUIRED_FIELD_MISSING",
+};
+async function runBuildProjectFlow(deps) {
+    const projectRoot = deps.fs.cwd();
+    const configPath = (0, config_loader_1.getDefaultConfigPath)(projectRoot, deps.fs.join);
+    let configResult;
+    try {
+        configResult = (0, config_loader_1.loadProjectConfig)({
+            readText: deps.fs.readText,
+        }, configPath);
+    }
+    catch (error) {
+        if (error instanceof config_loader_1.ConfigLoaderError) {
+            return (0, command_result_1.commandError)(error.message, CONFIG_ERROR_CODE_MAP[error.code], 1);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return (0, command_result_1.commandError)(message, command_result_1.COMMAND_ERROR_CODES.invalidPath, 1);
+    }
+    if (deps.executeBuild) {
+        try {
+            const result = await deps.executeBuild({
+                projectRoot,
+                configPath: configResult.configPath,
+                config: configResult.config,
+            });
+            return normalizeBuildResult(result);
+        }
+        catch (error) {
+            return (0, command_result_1.commandError)(formatExecuteBuildThrownError(error), command_result_1.COMMAND_ERROR_CODES.executionFailed, getNonZeroExitCode(error));
+        }
+    }
+    const commandRunner = (0, command_runner_1.createCommandRunner)();
+    const buildConfig = toBuildProjectConfig(configResult.config);
+    const buildTargets = getBuildTargets(projectRoot, buildConfig);
+    try {
+        for (const target of buildTargets) {
+            const output = await commandRunner({
+                command: "npm",
+                args: ["run", "build"],
+                cwd: target.projectDir,
+            });
+            if (output.exitCode !== 0) {
+                return (0, command_result_1.commandError)(`[${command_runner_1.COMMAND_RUNNER_STAGE}] 构建命令执行失败: npm run build (cwd=${target.projectDir}, exit=${output.exitCode})`, command_result_1.COMMAND_ERROR_CODES.executionFailed, output.exitCode);
+            }
+        }
+        copyBuildArtifacts(projectRoot, buildTargets);
+        copyConfiguredFiles(projectRoot, buildConfig.copyFiles);
+        return (0, command_result_1.commandOk)();
+    }
+    catch (error) {
+        if (error instanceof command_runner_1.ExecutionError) {
+            return (0, command_result_1.commandError)(error.message, command_result_1.COMMAND_ERROR_CODES.executionFailed, error.exitCode);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return (0, command_result_1.commandError)(`[${command_runner_1.COMMAND_RUNNER_STAGE}] 构建命令执行异常: npm run build (${message})`, command_result_1.COMMAND_ERROR_CODES.executionFailed, 1);
+    }
+}
+function getBuildTargets(projectRoot, config) {
+    return [...config.frontend, config.backend].map((item) => ({
+        ...item,
+        projectDir: resolveBuildTarget(projectRoot, item.projectDir),
+    }));
+}
+function toBuildProjectConfig(config) {
+    const frontendRaw = config.frontend;
+    const backendRaw = config.backend;
+    return {
+        frontend: frontendRaw.map((item) => toBuildTarget(item)),
+        backend: toBuildTarget(backendRaw),
+        copyFiles: toCopySpecs(config.copyFiles),
+    };
+}
+function toBuildTarget(item) {
+    const projectDir = asRequiredString(item.projectDir, "projectDir");
+    const packageSubDir = asRequiredString(item.packageSubDir, "packageSubDir");
+    const buildArtifactDirName = asOptionalString(item.buildArtifactDirName, "dist");
+    const artifactAlias = asOptionalString(item.artifactAlias, "dist");
+    return {
+        projectDir,
+        packageSubDir,
+        buildArtifactDirName,
+        artifactAlias,
+    };
+}
+function asRequiredString(value, fieldName) {
+    if (typeof value === "string" && value.trim() !== "") {
+        return value.trim();
+    }
+    throw new Error(`配置字段无效: ${fieldName}`);
+}
+function asOptionalString(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const normalized = value.trim();
+    return normalized === "" ? fallback : normalized;
+}
+function resolveBuildTarget(projectRoot, projectDir) {
+    return node_path_1.default.isAbsolute(projectDir)
+        ? projectDir
+        : node_path_1.default.resolve(projectRoot, projectDir);
+}
+function toCopySpecs(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((item, index) => toCopySpec(item, index));
+}
+function toCopySpec(item, index) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+        throw new Error(`配置字段无效: copyFiles[${index}]`);
+    }
+    const source = asRequiredString(item.source, `copyFiles[${index}].source`);
+    const dest = asRequiredString(item.dest, `copyFiles[${index}].dest`);
+    return { source, dest };
+}
+function copyBuildArtifacts(projectRoot, targets) {
+    for (const target of targets) {
+        const sourceDir = node_path_1.default.resolve(target.projectDir, target.buildArtifactDirName);
+        if (!(0, node_fs_1.existsSync)(sourceDir)) {
+            throw new Error(`[${command_runner_1.COMMAND_RUNNER_STAGE}] 构建产物不存在: ${sourceDir}`);
+        }
+        const targetDir = node_path_1.default.resolve(projectRoot, ".listpage", "output", target.packageSubDir, target.artifactAlias);
+        if ((0, node_fs_1.existsSync)(targetDir)) {
+            (0, node_fs_1.rmSync)(targetDir, { recursive: true, force: true });
+        }
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(targetDir), { recursive: true });
+        (0, node_fs_1.cpSync)(sourceDir, targetDir, { recursive: true });
+    }
+}
+function copyConfiguredFiles(projectRoot, copySpecs) {
+    for (const spec of copySpecs) {
+        const sourcePath = node_path_1.default.resolve(projectRoot, spec.source);
+        if (!(0, node_fs_1.existsSync)(sourcePath)) {
+            throw new Error(`[${command_runner_1.COMMAND_RUNNER_STAGE}] 复制源不存在: ${sourcePath}`);
+        }
+        const targetPath = node_path_1.default.resolve(projectRoot, ".listpage", "output", spec.dest);
+        if ((0, node_fs_1.existsSync)(targetPath)) {
+            (0, node_fs_1.rmSync)(targetPath, { recursive: true, force: true });
+        }
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(targetPath), { recursive: true });
+        const sourceIsDirectory = (0, node_fs_1.statSync)(sourcePath).isDirectory();
+        (0, node_fs_1.cpSync)(sourcePath, targetPath, { recursive: sourceIsDirectory });
+    }
+}
+function normalizeBuildResult(result) {
+    if (result.ok) {
+        if (result.exitCode === 0) {
+            return result;
+        }
+        return (0, command_result_1.commandError)(`[${command_runner_1.COMMAND_RUNNER_STAGE}] 构建命令执行失败: 执行器返回成功但退出码非零 (exit=${result.exitCode})`, command_result_1.COMMAND_ERROR_CODES.executionFailed, result.exitCode);
+    }
+    if (result.exitCode !== 0) {
+        return result;
+    }
+    return (0, command_result_1.commandError)(result.message ??
+        `[${command_runner_1.COMMAND_RUNNER_STAGE}] 构建命令执行失败: 执行器返回失败但退出码为 0`, result.errorCode ?? command_result_1.COMMAND_ERROR_CODES.executionFailed, 1);
+}
+function formatExecuteBuildThrownError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `[${command_runner_1.COMMAND_RUNNER_STAGE}] 构建命令执行异常: ${message}`;
+}
+function getNonZeroExitCode(error) {
+    if (!error || typeof error !== "object") {
+        return 1;
+    }
+    const candidate = error;
+    if (typeof candidate.exitCode === "number" && candidate.exitCode !== 0) {
+        return candidate.exitCode;
+    }
+    if (typeof candidate.status === "number" && candidate.status !== 0) {
+        return candidate.status;
+    }
+    return 1;
+}

package/bin/services/command-runner.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionError = exports.COMMAND_RUNNER_STAGE = void 0;
+exports.createCommandRunner = createCommandRunner;
+const node_child_process_1 = require("node:child_process");
+exports.COMMAND_RUNNER_STAGE = "build";
+class ExecutionError extends Error {
+    constructor(code, command, exitCode, message) {
+        super(message);
+        this.stage = exports.COMMAND_RUNNER_STAGE;
+        this.name = "ExecutionError";
+        this.code = code;
+        this.command = command;
+        this.exitCode = exitCode;
+    }
+}
+exports.ExecutionError = ExecutionError;
+function createCommandRunner(deps) {
+    const spawnSyncImpl = deps?.spawnSyncImpl ?? node_child_process_1.spawnSync;
+    return async (input) => {
+        const args = input.args ?? [];
+        const output = spawnSyncImpl(input.command, args, {
+            cwd: input.cwd,
+            env: {
+                ...process.env,
+                ...input.env,
+            },
+            shell: true,
+            stdio: "inherit",
+        });
+        if (output.error) {
+            const maybeNodeError = output.error;
+            const isNotFound = maybeNodeError.code === "ENOENT";
+            const code = isNotFound
+                ? "COMMAND_NOT_FOUND"
+                : "COMMAND_EXECUTION_FAILED";
+            const messagePrefix = isNotFound ? "命令不存在" : "命令执行异常";
+            throw new ExecutionError(code, input.command, 1, `[${exports.COMMAND_RUNNER_STAGE}][${code}] ${messagePrefix}: ${input.command} (${output.error.message})`);
+        }
+        return {
+            exitCode: output.status ?? 1,
+        };
+    };
+}

package/bin/services/config-loader.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoaderError = exports.CONFIG_LOADER_STAGE = void 0;
+exports.getDefaultConfigPath = getDefaultConfigPath;
+exports.loadProjectConfig = loadProjectConfig;
+exports.CONFIG_LOADER_STAGE = "config";
+const DEFAULT_CONFIG_NAME = "listpage.config.json";
+const REQUIRED_CONFIG_FIELDS = ["backend.projectDir", "backend.packageSubDir"];
+class ConfigLoaderError extends Error {
+    constructor(code, configPath, message) {
+        super(message);
+        this.stage = exports.CONFIG_LOADER_STAGE;
+        this.name = "ConfigLoaderError";
+        this.code = code;
+        this.configPath = configPath;
+    }
+}
+exports.ConfigLoaderError = ConfigLoaderError;
+function getDefaultConfigPath(projectRoot, join) {
+    return join(projectRoot, DEFAULT_CONFIG_NAME);
+}
+function loadProjectConfig(reader, configPath) {
+    const raw = readConfigText(reader, configPath);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new ConfigLoaderError("CONFIG_INVALID_JSON", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_INVALID_JSON] 无法解析配置文件: ${configPath} (${reason})`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ConfigLoaderError("CONFIG_INVALID_JSON", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_INVALID_JSON] 配置文件顶层必须是对象: ${configPath}`);
+    }
+    const config = parsed;
+    validateRequiredFields(config, configPath);
+    return {
+        configPath,
+        config,
+    };
+}
+function readConfigText(reader, configPath) {
+    try {
+        return reader.readText(configPath);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        const maybeNodeError = error;
+        const isNotFound = maybeNodeError?.code === "ENOENT";
+        const errorCode = isNotFound
+            ? "CONFIG_NOT_FOUND"
+            : "CONFIG_READ_FAILED";
+        const errorLabel = isNotFound ? "找不到配置文件" : "读取配置文件失败";
+        throw new ConfigLoaderError(errorCode, configPath, `[${exports.CONFIG_LOADER_STAGE}][${errorCode}] 无效项目上下文，${errorLabel}: ${configPath} (${reason})`);
+    }
+}
+function validateRequiredFields(config, configPath) {
+    const frontend = config.frontend;
+    if (!Array.isArray(frontend) || frontend.length === 0) {
+        throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: frontend (至少包含一个构建项)`);
+    }
+    frontend.forEach((item, index) => {
+        const projectDir = getNestedString({ frontend: item }, "frontend.projectDir");
+        if (!projectDir) {
+            throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: frontend[${index}].projectDir`);
+        }
+        const packageSubDir = getNestedString({ frontend: item }, "frontend.packageSubDir");
+        if (!packageSubDir) {
+            throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: frontend[${index}].packageSubDir`);
+        }
+    });
+    for (const field of REQUIRED_CONFIG_FIELDS) {
+        const value = getNestedString(config, field);
+        if (!value) {
+            throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: ${field}`);
+        }
+    }
+    validateCopyFiles(config, configPath);
+}
+function validateCopyFiles(config, configPath) {
+    const copyFiles = config.copyFiles;
+    if (copyFiles === undefined) {
+        return;
+    }
+    if (!Array.isArray(copyFiles)) {
+        throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: copyFiles (必须为数组)`);
+    }
+    copyFiles.forEach((item, index) => {
+        const source = getNestedString({ item }, "item.source");
+        if (!source) {
+            throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: copyFiles[${index}].source`);
+        }
+        const dest = getNestedString({ item }, "item.dest");
+        if (!dest) {
+            throw new ConfigLoaderError("CONFIG_REQUIRED_FIELD_MISSING", configPath, `[${exports.CONFIG_LOADER_STAGE}][CONFIG_REQUIRED_FIELD_MISSING] 配置缺少必填字段: copyFiles[${index}].dest`);
+        }
+    });
+}
+function getNestedString(source, dottedPath) {
+    const nodes = dottedPath.split(".");
+    let current = source;
+    for (const node of nodes) {
+        if (!current || typeof current !== "object" || Array.isArray(current)) {
+            return undefined;
+        }
+        current = current[node];
+    }
+    if (typeof current !== "string") {
+        return undefined;
+    }
+    const normalized = current.trim();
+    return normalized === "" ? undefined : normalized;
+}

package/bin/services/filesystem-capability-service.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilesystemCapabilityService = createFilesystemCapabilityService;
+const utils_1 = require("../utils");
+function createFilesystemCapabilityService(fs, options) {
+    return {
+        isDirEmpty: (dir) => {
+            return !fs.exists(dir) || fs.readDir(dir).length === 0;
+        },
+        copyRushTemplate: (targetDir, vars) => {
+            const source = getTemplateDir(fs, options.templateRootDir, "rush");
+            copyDir(fs, source, targetDir, vars);
+        },
+        updateRushJsonProjects: (filepath, feAppName, beAppName) => {
+            const projects = [];
+            if (feAppName) {
+                projects.push({
+                    packageName: (0, utils_1.composePkgName)(feAppName),
+                    projectFolder: `apps/${feAppName}`,
+                    reviewCategory: "production",
+                });
+            }
+            if (beAppName) {
+                projects.push({
+                    packageName: (0, utils_1.composePkgName)(beAppName),
+                    projectFolder: `servers/${beAppName}`,
+                    reviewCategory: "production",
+                });
+            }
+            const content = fs.readText(filepath);
+            const json = (0, utils_1.readJsonWithComments)(content);
+            json.projects = projects;
+            fs.writeText(filepath, JSON.stringify(json, null, 2));
+        },
+        copyFrontendTemplate: (targetDir, vars) => {
+            const appName = (0, utils_1.composePkgName)(vars.FRONTEND_NAME);
+            const resolvedTargetDir = fs.join(targetDir, `apps/${appName}`);
+            const source = getTemplateDir(fs, options.templateRootDir, "frontend");
+            copyDir(fs, source, resolvedTargetDir, vars);
+        },
+        copyBackendTemplate: (targetDir, vars) => {
+            const appName = (0, utils_1.composePkgName)(vars.BACKEND_NAME);
+            const resolvedTargetDir = fs.join(targetDir, `servers/${appName}`);
+            const source = getTemplateDir(fs, options.templateRootDir, "backend");
+            copyDir(fs, source, resolvedTargetDir, vars);
+        },
+        copyDeployScriptTemplate: (targetDir, vars) => {
+            const resolvedTargetDir = fs.join(targetDir, "common", "scripts", "package-app");
+            const source = getTemplateDir(fs, options.templateRootDir, "package-app");
+            copyDir(fs, source, resolvedTargetDir, vars);
+        },
+        copySkillDir: (sourceDir, targetDir) => {
+            syncDirWithRename(fs, sourceDir, targetDir);
+        },
+    };
+}
+function getTemplateDir(fs, templateRootDir, type) {
+    return fs.join(templateRootDir, `${type}-template`);
+}
+function copyDir(fs, source, destination, vars) {
+    fs.ensureDir(destination);
+    const files = fs.readDir(source);
+    files.forEach((file) => {
+        const sourcePath = fs.join(source, file);
+        const destinationPath = fs.join(destination, file);
+        if (fs.isDirectory(sourcePath)) {
+            copyDir(fs, sourcePath, destinationPath, vars);
+            return;
+        }
+        fs.ensureDir(fs.dirname(destinationPath));
+        const isTemplate = file.endsWith(".tmpl");
+        if (!isTemplate) {
+            fs.copyFile(sourcePath, destinationPath);
+            return;
+        }
+        const template = fs.readText(sourcePath);
+        const content = compileTemplateContent(template, vars);
+        fs.writeText(destinationPath.slice(0, -5), content);
+    });
+}
+function compileTemplateContent(source, vars) {
+    let output = source;
+    for (const [key, value] of Object.entries(vars)) {
+        const re = new RegExp(`__${key}__`, "g");
+        output = output.replace(re, value);
+    }
+    return output;
+}
+function syncDirWithRename(fs, source, destination) {
+    fs.ensureDir(destination);
+    const items = fs.readDir(source);
+    items.forEach((name) => {
+        const sourcePath = fs.join(source, name);
+        const destinationPath = fs.join(destination, name);
+        if (fs.isDirectory(sourcePath)) {
+            if (fs.exists(destinationPath) && !fs.isDirectory(destinationPath)) {
+                fs.rename(destinationPath, getCopyPath(fs, destinationPath));
+            }
+            fs.ensureDir(destinationPath);
+            syncDirWithRename(fs, sourcePath, destinationPath);
+            return;
+        }
+        fs.ensureDir(fs.dirname(destinationPath));
+        if (fs.exists(destinationPath) && !fs.isDirectory(destinationPath)) {
+            fs.rename(destinationPath, getCopyPath(fs, destinationPath));
+        }
+        fs.copyFile(sourcePath, destinationPath);
+    });
+}
+function getCopyPath(fs, filePath) {
+    const dir = fs.dirname(filePath);
+    const { base, ext } = splitFileName(filePath);
+    let candidate = fs.join(dir, `${base} copy${ext}`);
+    if (!fs.exists(candidate)) {
+        return candidate;
+    }
+    let index = 2;
+    while (true) {
+        candidate = fs.join(dir, `${base} copy (${index})${ext}`);
+        if (!fs.exists(candidate)) {
+            return candidate;
+        }
+        index += 1;
+    }
+}
+function splitFileName(filePath) {
+    const fileName = filePath.split(/[\\/]/).pop() ?? filePath;
+    const extIndex = fileName.lastIndexOf(".");
+    if (extIndex <= 0) {
+        return { base: fileName, ext: "" };
+    }
+    return {
+        base: fileName.slice(0, extIndex),
+        ext: fileName.slice(extIndex),
+    };
+}