cocos-enhance-kit/scripts/index.js

import { confirm, input } from "@inquirer/prompts";
import { $ } from "execa";
import gracefulFs from "graceful-fs";
import { Octokit } from 'octokit';
import { basename, extname, join } from "path";
import { cwd, env } from "process";
import { Client } from 'ssh2';
import { Zip } from 'zip-lib';
const { createReadStream, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } = gracefulFs;

// 公共函数
const $$ = $({ stdout: 'inherit', stderr: 'inherit' });

function copyDirectory(sourceDir, targetDir) {
    // 创建目标目录
    mkdirSync(targetDir, { recursive: true });

    // 读取源目录中的文件和子目录
    const files = readdirSync(sourceDir);

    // 遍历源目录中的文件和子目录
    files.forEach((file) => {
        const sourcePath = join(sourceDir, file);
        const targetPath = join(targetDir, file);

        // 判断是否为文件
        if (statSync(sourcePath).isFile()) {
            // 如果是文件，则直接拷贝到目标目录
            copyFileSync(sourcePath, targetPath);
        } else {
            // 如果是子目录，则递归调用copyDir函数进行拷贝
            copyDir(sourcePath, targetPath);
        }
    });
}

async function uploadBySFTP(host, port, username, password, filePath, targetFilePath) {
    return new Promise((resolve, reject) => {
        const client = new Client();

        client.on('ready', () => {
            console.log('SSH 连接已建立');
            client.sftp((err, sftp) => {
                if (err) {
                    reject(err);
                    client.end();
                    return;
                }
                sftp.exists(targetFilePath, hasErr => {
                    if (!hasErr) {
                        resolve();
                        client.end();
                        return;
                    }

                    const readStream = createReadStream(filePath);
                    const writeStream = sftp.createWriteStream(targetFilePath);

                    writeStream.on('close', () => {
                        resolve();
                        client.end();
                    });

                    writeStream.on('error', (err) => {
                        reject(err);
                        client.end();
                    });

                    readStream.pipe(writeStream);
                });
            });
        });

        client.on('error', (err) => {
            reject(err);
        });

        client.connect({
            host,
            port,
            username,
            password,
        });
    });
}

// 试运行
const DRYRUN = true;

// 目录
const masterPath = cwd();
const sourcePath = await input({
    message: "请输入源码分支目录：",
    required: true,
    default: "/Users/smallmain/Documents/Work/cocos-service-pack-src",
});
const extensionPath = await input({
    message: "请输入付费扩展目录（如果有的话）：",
    required: false,
    default: "/Users/smallmain/Documents/Work/cocos-service-pack-extension",
});

console.log("主分支目录：", masterPath);
console.log("源码目录：", sourcePath);
console.log("付费扩展目录：", extensionPath);

// 版本号
const engineVersion = await input({
    message: "请输入发布的引擎版本：",
    required: true,
    default: "1.0.0",
});
const kitVersion = await input({
    message: "请输入发布的社区版版本：",
    required: true,
    default: "1.0.0",
});

// 更新源码 VERSION.md
readdirSync(sourcePath, {
    recursive: true,
    encoding: "utf-8",
})
    .filter(path => basename(path) === "VERSION.md")
    .forEach(path => {
        const filePath = join(sourcePath, path);

        if (!DRYRUN) {
            writeFileSync(filePath, kitVersion);
        }

        console.log("更新文件", filePath);
    });

// 更新源码 README.md
const SOURCE_README = `Cocos Enhance Kit v${kitVersion} 引擎源码\n\n适配 v${engineVersion} 引擎\n`;
const sourceReadmePath = join(sourcePath, "README.md");
if (!DRYRUN) {
    writeFileSync(sourceReadmePath, SOURCE_README);
}
console.log("更新文件", sourceReadmePath);

// 更新 sp.js 版本号
const SPJS_REGEX = /version:\s*"(.*?)"/;
const spjsPath = join(sourcePath, "engine/cocos2d/core/sp/sp.js");
const newSpjsContent = readFileSync(spjsPath, { encoding: "utf-8" })
    .replace(SPJS_REGEX, `version: "${kitVersion}"`);
if (!DRYRUN) {
    writeFileSync(spjsPath, newSpjsContent);
}
console.log("更新文件", spjsPath);

// 确保支持性扩展 package.json 版本号正确
const supportPath = join(sourcePath, "extension");
const supportPackageJsonPath = join(supportPath, "package.json");
const supportPackageJson = JSON.parse(readFileSync(supportPackageJsonPath, { encoding: "utf-8" }));
supportPackageJson.version = kitVersion;
if (!DRYRUN) {
    writeFileSync(supportPackageJsonPath, JSON.stringify(supportPackageJson, null, 2));
}
console.log("更新文件", supportPackageJsonPath);

// 准备压缩包
const cppPath = join(sourcePath, "cocos2d-x");
const cppBuildPath = join(cppPath, "build/build");
const jsPath = join(sourcePath, "engine");
const jsNpmPath = join(jsPath, "node_modules");
const jsbPath = join(sourcePath, "jsb-adapter");
const minigamePath = join(sourcePath, "adapters");
const dtsPath = join(sourcePath, "creator-sp.d.ts");
const zipPath = join(masterPath, `cocos-enhance-kit-v${kitVersion}-v${engineVersion}.zip`);

if (!DRYRUN) {
    rmSync(cppBuildPath, { force: true, recursive: true });
    rmSync(jsNpmPath, { force: true, recursive: true });
}
console.log("删除目录", cppBuildPath);
console.log("删除目录", jsNpmPath);
if (!DRYRUN) {
    console.log("开始编译 JavaScript 引擎");
    try {
        await $$({ cwd: jsPath })`gulp build-dev`;
    } catch (error) {
        await confirm({
            message: `自动编译 JavaScript 引擎失败，请手动编译后继续`,
            default: true,
        });
    }
}
console.log("已编译 JavaScript 引擎");
if (!DRYRUN) {
    console.log("开始编译当前平台的原生模拟器");
    try {
        await $$({ cwd: cppPath })`gulp gen-simulator`;
        await $$({ cwd: cppPath })`gulp update-simulator-config`;
    } catch (error) {
        await confirm({
            message: `自动编译当前平台的原生模拟器失败，请手动编译后继续`,
            default: true,
        });
    }
}
console.log("已编译当前平台的原生模拟器");

// 创建压缩包
if (!DRYRUN) {
    const sourceZipFile = new Zip();
    console.log("正在压缩", jsPath);
    sourceZipFile.addFolder(jsPath, "engine");
    console.log("正在压缩", cppPath);
    sourceZipFile.addFolder(cppPath, "cocos2d-x");
    console.log("正在压缩", jsbPath);
    sourceZipFile.addFolder(jsbPath, "jsb-adapter");
    console.log("正在压缩", minigamePath);
    sourceZipFile.addFolder(minigamePath, "adapters");
    console.log("正在压缩", supportPath);
    sourceZipFile.addFolder(supportPath, "extension");
    console.log("正在压缩", dtsPath);
    sourceZipFile.addFile(dtsPath);
    await sourceZipFile.archive(zipPath);
}
console.log("已压缩至文件", zipPath);

// [付费扩展]
if (extensionPath) {
    // 创建压缩包
    const payZipPath = join(masterPath, `${kitVersion}.zip`);
    if (!DRYRUN) {
        const sourceZipFile = new Zip();
        console.log("正在压缩", jsPath);
        sourceZipFile.addFolder(jsPath, `${kitVersion}/engine`);
        console.log("正在压缩", cppPath);
        sourceZipFile.addFolder(cppPath, `${kitVersion}/cocos2d-x`);
        console.log("正在压缩", jsbPath);
        sourceZipFile.addFolder(jsbPath, `${kitVersion}/jsb-adapter`);
        console.log("正在压缩", minigamePath);
        sourceZipFile.addFolder(minigamePath, `${kitVersion}/adapters`);
        console.log("正在压缩", dtsPath);
        sourceZipFile.addFile(dtsPath, `${kitVersion}/creator-sp.d.ts`);
        await sourceZipFile.archive(payZipPath);
    }
    console.log("已压缩至文件", payZipPath);

    // 上传至 downloadcdn.smallmain.com
    const payZipUrl = `http://downloadcdn.smallmain.com/cocos-enhance-kit/${engineVersion}/${kitVersion}.zip`;
    if (!DRYRUN) {
        console.log("正在上传文件", payZipPath);
        await uploadBySFTP(
            env.HOST,
            env.PORT,
            env.USERNAME,
            env.PASSWORD,
            payZipPath,
            `/www/wwwroot/download.smallmain.com/cocos-enhance-kit/${engineVersion}/${kitVersion}.zip`,
        );
    }
    console.log("已上传文件", payZipUrl);

    // 手动修改 config.json
    await confirm({
        message: `请将压缩文件上传至各网盘，并修改 config.json 指向下载链接`,
        default: true,
    });

    // 手动修改 package.json 的 version 字段
    await confirm({
        message: `请修改 package.json 的 version 确定版本号后继续`,
        default: true,
    });

    // 压缩为扩展 zip 文件
    const extensionVersion = JSON.parse(readFileSync(join(extensionPath, "package.json"), { encoding: "utf-8" })).version;
    const extensionZipPath = join(masterPath, `cocos-enhance-kit-extension-v${extensionVersion}.zip`);
    if (!DRYRUN) {
        const sourceZipFile = new Zip();
        readdirSync(extensionPath, { withFileTypes: true })
            .filter(v => v.name !== "packages")
            .forEach(v => {
                const path = join(v.path, v.name);
                console.log("正在压缩", path);
                if (v.isFile()) {
                    sourceZipFile.addFile(path, v.name);
                } else {
                    sourceZipFile.addFolder(path, v.name);
                }
            });

        // packages 目录需要仅保留 backup 目录，所以特殊处理
        const packagesPath = join(extensionPath, "packages");
        readdirSync(packagesPath, { withFileTypes: true })
            .forEach(v => {
                if (v.isFile()) {
                    const path = join(v.path, v.name);
                    console.log("正在压缩", path);
                    sourceZipFile.addFile(path, join("packages", v.name));
                } else {
                    const relPath = join(v.name, "backup");
                    const path = join(v.path, relPath);
                    console.log("正在压缩", path);
                    sourceZipFile.addFolder(path, join("packages", relPath));
                }
            });

        await sourceZipFile.archive(extensionZipPath);
    }
    console.log("已压缩至文件", extensionZipPath);

    //  手动上传到 Cocos Store
    await confirm({
        message: `请手动上传 zip 文件到 Cocos Store`,
        default: true,
    });
}

// 更新 Demo
const demoBuildPath = join(masterPath, "demo/build");
const demoDesktopBuildPath = join(demoBuildPath, "web-desktop");
const demoMobileBuildPath = join(demoBuildPath, "web-mobile");
const demoTargetPath = join(masterPath, "docs/static/demo", `v${kitVersion}`);
const demoDesktopTargetPath = join(demoTargetPath, "web-desktop");
const demoMobileTargetPath = join(demoTargetPath, "web-mobile");
if (!existsSync(demoTargetPath)) {
    await confirm({
        message: `请测试并编译 Demo 项目，然后继续操作`,
        default: true,
    });
    if (!DRYRUN) {
        copyDirectory(demoDesktopBuildPath, demoDesktopTargetPath);
        copyDirectory(demoMobileBuildPath, demoMobileTargetPath);
    }
    console.log("拷贝目录", demoDesktopBuildPath, "->", demoDesktopTargetPath);
    console.log("拷贝目录", demoMobileBuildPath, "->", demoMobileTargetPath);
}
readdirSync(masterPath, {
    recursive: true,
    encoding: "utf-8",
})
    .filter(path => [".ts", ".tsx", ".js", ".jsx", ".md", ".mdx"].includes(extname(path)))
    .forEach(path => {
        const filePath = join(masterPath, path);

        if (!statSync(filePath).isFile()) {
            return;
        }

        const content = readFileSync(filePath, { encoding: "utf-8" });
        const regexDesktop = /https:\/\/smallmain\.github\.io\/cocos-enhance-kit\/demo\/(v\d+\.\d+\.\d+)\/web-desktop\/index\.html/g;
        const regexMobile = /https:\/\/smallmain\.github\.io\/cocos-enhance-kit\/demo\/(v\d+\.\d+\.\d+)\/web-mobile\/index\.html/g;

        if (!DRYRUN) {
            writeFileSync(filePath, content.replace(regexDesktop, `https://smallmain.github.io/cocos-enhance-kit/demo/${targetVersion}/web-desktop/index.html`).replace(regexMobile, `https://smallmain.github.io/cocos-enhance-kit/demo/${targetVersion}/web-mobile/index.html`));
        }

        if (regexDesktop.test(content) || regexMobile.test(content)) {
            console.log("更新文件", filePath);
        }
    });


// 上传到 Github Release
const tag = `v${kitVersion}`;
let releaseUrl = "(undefined)";
const needPublish = await confirm({
    message: `是否上传至 Github Release？（请先在源码分支创建 '${tag}' Tag）`,
    default: true,
});
if (needPublish && !DRYRUN) {

    const octokit = new Octokit({
        auth: env.GITHUB_TOKEN,
    });

    console.log("创建 Release：", tag);

    let releaseId = 0;
    try {
        const { data } = await octokit.rest.repos.getReleaseByTag({
            owner: "smallmain",
            repo: "cocos-enhance-kit",
            tag: tag,
        });
        releaseId = data.id;
        releaseUrl = data.html_url;
    } catch (error) {
        const { data } = await octokit.rest.repos.createRelease({
            owner: "smallmain",
            repo: "cocos-enhance-kit",
            name: tag,
            tag_name: tag,
            body: `适配 Cocos Creator v${engineVersion} 版本\n\n> 注意，如果你需要使用模拟器预览，请按照官方的 [引擎定制文档](https://docs.cocos.com/creator/2.4/manual/zh/advanced-topics/engine-customization.html#25-%E7%BC%96%E8%AF%91%E6%A8%A1%E6%8B%9F%E5%99%A8) 重新编译原生模拟器。`,
            prerelease: false,
            make_latest: "legacy",
        });
        releaseId = data.id;
        releaseUrl = data.html_url;
    }

    console.log("上传至 Release：", zipPath);
    const fileContent = readFileSync(zipPath);
    await octokit.rest.repos.uploadReleaseAsset({
        owner: "smallmain",
        repo: "cocos-enhance-kit",
        release_id: releaseId,
        data: fileContent,
        name: basename(zipPath),
        headers: {
            'content-type': 'application/zip',
        },
    });
}
console.log("已发布到 Github Release：", tag);

// 手动更新 Github Release 的更新日志
if (needPublish) {
    await confirm({
        message: `请前往 ${releaseUrl} 填写更新日志`,
        default: true,
    });
}

// 手动发布新版本文档
await confirm({
    message: `请使用命令 npm run docusaurus docs:version 1.1.0 创建新版本文档，并在 docs 目录执行 npm run deploy 发布`,
    default: true,
});