1563 lines
43 KiB
JavaScript
1563 lines
43 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
/**
|
||
* 统一混合部署脚本
|
||
*
|
||
* 一键完成：
|
||
* 1. 构建项目
|
||
* 2. 运行 E2E 冒烟测试
|
||
* 3. 分离 HTML 和静态资源
|
||
* 4. 发布静态资源到 npm CDN
|
||
* 5. 部署 HTML 到自有服务器
|
||
* 6. 生成用户手册
|
||
*
|
||
* 用法：
|
||
* node scripts/deploy-hybrid.js [options]
|
||
*
|
||
* 选项：
|
||
* --skip-build 跳过构建步骤
|
||
* --skip-npm 跳过 npm 发布
|
||
* --skip-server 跳过服务器部署
|
||
* --skip-e2e 跳过 E2E 测试
|
||
* --skip-manual 跳过手册生成
|
||
* --dry-run 预览模式，不实际执行
|
||
* --otp=123456 npm 2FA 验证码
|
||
* --bump-if-published=minor 当前版本已发布时才升级版本
|
||
*/
|
||
|
||
const fs = require('fs');
|
||
const http = require('http');
|
||
const https = require('https');
|
||
const path = require('path');
|
||
const { execSync } = require('child_process');
|
||
|
||
// ============================================
|
||
// 配置
|
||
// ============================================
|
||
|
||
const CONFIG = {
|
||
packageName: 'aitu-app',
|
||
distDir: path.resolve(__dirname, '../dist/apps/web'),
|
||
outputServer: path.resolve(__dirname, '../dist/deploy/server'),
|
||
outputCDN: path.resolve(__dirname, '../dist/deploy/cdn'),
|
||
cdnTemplates: {
|
||
unpkg: 'https://unpkg.com/aitu-app@{version}',
|
||
jsdelivr: 'https://cdn.jsdelivr.net/npm/aitu-app@{version}',
|
||
},
|
||
runtimeCdnProvider: 'jsdelivr',
|
||
// 只在服务器的文件
|
||
serverOnlyFiles: [
|
||
'index.html',
|
||
'sw-debug.html',
|
||
'cdn-debug.html',
|
||
'versions.html',
|
||
'iframe-test.html',
|
||
],
|
||
// 不上传到 CDN 的模式
|
||
excludeFromCDN: [/\.html$/, /^init\.json$/, /\.map$/],
|
||
};
|
||
|
||
// ============================================
|
||
// 命令行参数
|
||
// ============================================
|
||
|
||
const args = process.argv.slice(2);
|
||
const skipBuild = args.includes('--skip-build');
|
||
const skipNpm = args.includes('--skip-npm');
|
||
const skipServer = args.includes('--skip-server');
|
||
const skipE2E = args.includes('--skip-e2e');
|
||
const skipManual = args.includes('--skip-manual');
|
||
const isDryRun = args.includes('--dry-run');
|
||
const otpArg = args.find((arg) => arg.startsWith('--otp='));
|
||
const otp = otpArg ? otpArg.split('=')[1] : null;
|
||
const bumpIfPublishedArg = args.find((arg) =>
|
||
arg.startsWith('--bump-if-published=')
|
||
);
|
||
const bumpIfPublished = bumpIfPublishedArg
|
||
? bumpIfPublishedArg.split('=')[1]
|
||
: 'patch';
|
||
const validBumpTypes = new Set(['patch', 'minor', 'major']);
|
||
|
||
if (!validBumpTypes.has(bumpIfPublished)) {
|
||
console.error(
|
||
`Invalid --bump-if-published value: ${bumpIfPublished}. Use patch, minor, or major.`
|
||
);
|
||
process.exit(1);
|
||
}
|
||
const cdnProvider = 'unpkg';
|
||
|
||
// ============================================
|
||
// 工具函数
|
||
// ============================================
|
||
|
||
const colors = {
|
||
reset: '\x1b[0m',
|
||
green: '\x1b[32m',
|
||
yellow: '\x1b[33m',
|
||
blue: '\x1b[34m',
|
||
red: '\x1b[31m',
|
||
cyan: '\x1b[36m',
|
||
gray: '\x1b[90m',
|
||
};
|
||
|
||
function log(message, color = 'reset') {
|
||
console.log(`${colors[color]}${message}${colors.reset}`);
|
||
}
|
||
|
||
function logStep(step, total, message) {
|
||
log(
|
||
`\n[${'='.repeat(step)}${'-'.repeat(
|
||
total - step
|
||
)}] 步骤 ${step}/${total}: ${message}`,
|
||
'blue'
|
||
);
|
||
}
|
||
|
||
function logSuccess(message) {
|
||
log(` ✓ ${message}`, 'green');
|
||
}
|
||
|
||
function logWarning(message) {
|
||
log(` ⚠ ${message}`, 'yellow');
|
||
}
|
||
|
||
function logError(message) {
|
||
log(` ✗ ${message}`, 'red');
|
||
}
|
||
|
||
function formatExecError(error) {
|
||
if (!error) {
|
||
return '未知错误';
|
||
}
|
||
|
||
const stderr =
|
||
typeof error.stderr === 'string'
|
||
? error.stderr.trim()
|
||
: Buffer.isBuffer(error.stderr)
|
||
? error.stderr.toString('utf-8').trim()
|
||
: '';
|
||
const stdout =
|
||
typeof error.stdout === 'string'
|
||
? error.stdout.trim()
|
||
: Buffer.isBuffer(error.stdout)
|
||
? error.stdout.toString('utf-8').trim()
|
||
: '';
|
||
|
||
return stderr || stdout || error.message || '未知错误';
|
||
}
|
||
|
||
function exec(command, options = {}) {
|
||
log(
|
||
` 执行: ${command.substring(0, 80)}${command.length > 80 ? '...' : ''}`,
|
||
'gray'
|
||
);
|
||
try {
|
||
if (isDryRun) {
|
||
log(` [DRY RUN] 跳过执行`, 'yellow');
|
||
return true;
|
||
}
|
||
execSync(command, { stdio: 'inherit', ...options });
|
||
return true;
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function ensureDir(dir) {
|
||
if (!fs.existsSync(dir)) {
|
||
fs.mkdirSync(dir, { recursive: true });
|
||
}
|
||
}
|
||
|
||
function copyFile(src, dest) {
|
||
ensureDir(path.dirname(dest));
|
||
fs.copyFileSync(src, dest);
|
||
}
|
||
|
||
function getVersion() {
|
||
const versionPath = path.resolve(
|
||
__dirname,
|
||
'../apps/web/public/version.json'
|
||
);
|
||
if (fs.existsSync(versionPath)) {
|
||
return JSON.parse(fs.readFileSync(versionPath, 'utf-8')).version;
|
||
}
|
||
const pkgPath = path.resolve(__dirname, '../package.json');
|
||
return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
|
||
}
|
||
|
||
function shouldUploadToCDN(filename) {
|
||
return !CONFIG.excludeFromCDN.some((pattern) =>
|
||
pattern instanceof RegExp ? pattern.test(filename) : filename === pattern
|
||
);
|
||
}
|
||
|
||
function shouldKeepOnServer(filename) {
|
||
return CONFIG.serverOnlyFiles.some(
|
||
(f) => filename === f || filename.endsWith(f)
|
||
);
|
||
}
|
||
|
||
function getTagAttribute(tag, attributeName) {
|
||
const escapedName = attributeName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||
const match = String(tag).match(
|
||
new RegExp(`\\s${escapedName}\\s*=\\s*(['"])(.*?)\\1`, 'i')
|
||
);
|
||
return match ? match[2] : '';
|
||
}
|
||
|
||
function stripUrlQueryAndHash(value) {
|
||
return String(value || '').split(/[?#]/, 1)[0];
|
||
}
|
||
|
||
function normalizeAssetPath(value) {
|
||
let normalized = stripUrlQueryAndHash(value).trim();
|
||
if (!normalized) {
|
||
return '';
|
||
}
|
||
|
||
if (/^https?:\/\//i.test(normalized)) {
|
||
try {
|
||
normalized = new URL(normalized).pathname;
|
||
} catch (_error) {
|
||
return '';
|
||
}
|
||
}
|
||
|
||
normalized = normalized
|
||
.replace(/^\.\//, '/')
|
||
.replace(/^\/?npm\/aitu-app@[^/]+\//, '/')
|
||
.replace(/^\/?aitu-app@[^/]+\//, '/');
|
||
|
||
if (!normalized.startsWith('/')) {
|
||
normalized = `/${normalized}`;
|
||
}
|
||
|
||
return normalized;
|
||
}
|
||
|
||
function getRuntimeCdnAssetInfo(assetUrl) {
|
||
if (!/^https?:\/\//i.test(String(assetUrl || ''))) {
|
||
return null;
|
||
}
|
||
|
||
let parsedUrl;
|
||
try {
|
||
parsedUrl = new URL(assetUrl);
|
||
} catch (_error) {
|
||
return null;
|
||
}
|
||
|
||
const jsdelivrPrefix = `/npm/${CONFIG.packageName}@`;
|
||
if (
|
||
parsedUrl.hostname === 'cdn.jsdelivr.net' &&
|
||
parsedUrl.pathname.startsWith(jsdelivrPrefix)
|
||
) {
|
||
const rest = parsedUrl.pathname.slice(jsdelivrPrefix.length);
|
||
const slashIndex = rest.indexOf('/');
|
||
if (slashIndex === -1) {
|
||
return null;
|
||
}
|
||
return {
|
||
provider: 'jsdelivr',
|
||
version: rest.slice(0, slashIndex),
|
||
assetPath: normalizeAssetPath(rest.slice(slashIndex + 1)),
|
||
url: parsedUrl.toString(),
|
||
};
|
||
}
|
||
|
||
const unpkgPrefix = `/${CONFIG.packageName}@`;
|
||
if (
|
||
parsedUrl.hostname === 'unpkg.com' &&
|
||
parsedUrl.pathname.startsWith(unpkgPrefix)
|
||
) {
|
||
const rest = parsedUrl.pathname.slice(unpkgPrefix.length);
|
||
const slashIndex = rest.indexOf('/');
|
||
if (slashIndex === -1) {
|
||
return null;
|
||
}
|
||
return {
|
||
provider: 'unpkg',
|
||
version: rest.slice(0, slashIndex),
|
||
assetPath: normalizeAssetPath(rest.slice(slashIndex + 1)),
|
||
url: parsedUrl.toString(),
|
||
};
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
function collectEntryAssetReferences(html, version) {
|
||
const references = [];
|
||
|
||
function pushReference(tag, urlAttribute, localAttribute, expectedExtension) {
|
||
const url = getTagAttribute(tag, urlAttribute);
|
||
const localUrl = getTagAttribute(tag, localAttribute);
|
||
const assetPath = normalizeAssetPath(localUrl || url);
|
||
if (
|
||
!assetPath.startsWith('/assets/') ||
|
||
!assetPath.endsWith(expectedExtension)
|
||
) {
|
||
return;
|
||
}
|
||
|
||
const cdnInfo = getRuntimeCdnAssetInfo(url);
|
||
const errors = [];
|
||
const expectedCdnBaseUrl = CONFIG.cdnTemplates[
|
||
CONFIG.runtimeCdnProvider
|
||
].replace('{version}', version);
|
||
const expectedCdnUrl = `${expectedCdnBaseUrl}${assetPath}`;
|
||
|
||
if (cdnInfo) {
|
||
if (cdnInfo.provider !== CONFIG.runtimeCdnProvider) {
|
||
errors.push(`provider:${cdnInfo.provider}`);
|
||
}
|
||
if (cdnInfo.version !== version) {
|
||
errors.push(`version:${cdnInfo.version}`);
|
||
}
|
||
if (cdnInfo.assetPath !== assetPath) {
|
||
errors.push(`path:${cdnInfo.assetPath}`);
|
||
}
|
||
} else if (/^https?:\/\//i.test(url)) {
|
||
errors.push(`unexpected-url:${url}`);
|
||
}
|
||
|
||
references.push({
|
||
assetPath,
|
||
url,
|
||
expectedCdnUrl,
|
||
tagName: expectedExtension === '.js' ? 'script' : 'stylesheet',
|
||
errors,
|
||
});
|
||
}
|
||
|
||
const scriptTags =
|
||
String(html).match(
|
||
/<script\b[^>]*\bsrc\s*=\s*(['"]).*?\1[^>]*><\/script>/gi
|
||
) || [];
|
||
for (const tag of scriptTags) {
|
||
pushReference(tag, 'src', 'data-local-src', '.js');
|
||
}
|
||
|
||
const linkTags = String(html).match(/<link\b[^>]*>/gi) || [];
|
||
for (const tag of linkTags) {
|
||
const rel = getTagAttribute(tag, 'rel').toLowerCase();
|
||
if (rel.split(/\s+/).includes('stylesheet')) {
|
||
pushReference(tag, 'href', 'data-local-href', '.css');
|
||
}
|
||
}
|
||
|
||
const uniqueReferences = new Map();
|
||
for (const reference of references) {
|
||
if (!uniqueReferences.has(reference.assetPath)) {
|
||
uniqueReferences.set(reference.assetPath, reference);
|
||
}
|
||
}
|
||
|
||
return Array.from(uniqueReferences.values());
|
||
}
|
||
|
||
function requestUrl(url, timeoutMs = 10000) {
|
||
return new Promise((resolve, reject) => {
|
||
const client = url.startsWith('https:') ? https : http;
|
||
const request = client.get(url, (response) => {
|
||
const chunks = [];
|
||
response.on('data', (chunk) => {
|
||
chunks.push(chunk);
|
||
});
|
||
response.on('end', () => {
|
||
resolve({
|
||
statusCode: response.statusCode || 0,
|
||
headers: response.headers,
|
||
body: Buffer.concat(chunks),
|
||
});
|
||
});
|
||
});
|
||
|
||
request.setTimeout(timeoutMs, () => {
|
||
request.destroy(new Error(`timeout:${timeoutMs}`));
|
||
});
|
||
request.on('error', reject);
|
||
});
|
||
}
|
||
|
||
async function isRemoteAssetReady(url) {
|
||
try {
|
||
const response = await requestUrl(url, 10000);
|
||
if (response.statusCode !== 200) {
|
||
return {
|
||
ok: false,
|
||
reason: `status:${response.statusCode}`,
|
||
};
|
||
}
|
||
|
||
const contentType = String(response.headers['content-type'] || '');
|
||
const body = response.body;
|
||
const isTextAsset =
|
||
url.endsWith('.js') || url.endsWith('.css') || url.endsWith('.json');
|
||
const looksLikeHtml =
|
||
isTextAsset &&
|
||
body.length > 0 &&
|
||
body
|
||
.subarray(0, Math.min(body.length, 200))
|
||
.toString('utf8')
|
||
.match(/<!DOCTYPE|<html|<HTML|Not Found|404/);
|
||
|
||
if (looksLikeHtml) {
|
||
return { ok: false, reason: 'html-fallback' };
|
||
}
|
||
|
||
if (isTextAsset && body.length > 0 && body.length < 50) {
|
||
return { ok: false, reason: `body-too-small:${body.length}` };
|
||
}
|
||
|
||
if (!contentType) {
|
||
return { ok: true };
|
||
}
|
||
|
||
if (
|
||
url.endsWith('.js') &&
|
||
!contentType.includes('javascript') &&
|
||
!contentType.includes('ecmascript')
|
||
) {
|
||
return { ok: false, reason: `invalid-content-type:${contentType}` };
|
||
}
|
||
|
||
if (url.endsWith('.css') && !contentType.includes('css')) {
|
||
return { ok: false, reason: `invalid-content-type:${contentType}` };
|
||
}
|
||
|
||
return { ok: true };
|
||
} catch (error) {
|
||
return {
|
||
ok: false,
|
||
reason: error.message || String(error),
|
||
};
|
||
}
|
||
}
|
||
|
||
function getCriticalCdnAssets(version) {
|
||
const indexHtmlPath = path.join(CONFIG.outputServer, 'index.html');
|
||
const precacheManifestPath = path.join(
|
||
CONFIG.outputCDN,
|
||
'precache-manifest.json'
|
||
);
|
||
|
||
if (!fs.existsSync(indexHtmlPath)) {
|
||
return { ok: false, reason: 'server/index.html 不存在' };
|
||
}
|
||
|
||
if (!fs.existsSync(precacheManifestPath)) {
|
||
return { ok: false, reason: 'cdn/precache-manifest.json 不存在' };
|
||
}
|
||
|
||
const html = fs.readFileSync(indexHtmlPath, 'utf-8');
|
||
const manifest = JSON.parse(fs.readFileSync(precacheManifestPath, 'utf-8'));
|
||
const manifestUrls = new Set((manifest.files || []).map((file) => file.url));
|
||
const entryReferences = collectEntryAssetReferences(html, version);
|
||
|
||
if (entryReferences.length === 0) {
|
||
return { ok: false, reason: '未找到入口关键静态资源' };
|
||
}
|
||
|
||
const cdnUrlErrors = entryReferences.filter(
|
||
(reference) => reference.errors.length > 0
|
||
);
|
||
if (cdnUrlErrors.length > 0) {
|
||
return {
|
||
ok: false,
|
||
reason: `入口 HTML 的 CDN 地址与发布版本不一致: ${cdnUrlErrors
|
||
.slice(0, 5)
|
||
.map(
|
||
(reference) =>
|
||
`${reference.assetPath} (${reference.errors.join(', ')})`
|
||
)
|
||
.join('; ')}`,
|
||
};
|
||
}
|
||
|
||
const missingAssets = entryReferences
|
||
.map((reference) => reference.assetPath)
|
||
.filter((assetPath) => !manifestUrls.has(assetPath));
|
||
if (missingAssets.length > 0) {
|
||
return {
|
||
ok: false,
|
||
reason: `入口 HTML 引用的关键资源未进入 CDN 包清单: ${missingAssets
|
||
.slice(0, 8)
|
||
.join(', ')}`,
|
||
};
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
assets: entryReferences.map((reference) => ({
|
||
assetPath: reference.assetPath,
|
||
url: reference.expectedCdnUrl,
|
||
tagName: reference.tagName,
|
||
})),
|
||
};
|
||
}
|
||
|
||
async function waitForRuntimeCdnAssetsReady(version) {
|
||
const runtimeCdnBaseUrl = CONFIG.cdnTemplates[
|
||
CONFIG.runtimeCdnProvider
|
||
].replace('{version}', version);
|
||
const criticalAssetsResult = getCriticalCdnAssets(version);
|
||
|
||
if (!criticalAssetsResult.ok) {
|
||
return criticalAssetsResult;
|
||
}
|
||
|
||
const criticalAssets = criticalAssetsResult.assets.slice(0, 6);
|
||
const timeoutMs = 10 * 60 * 1000;
|
||
const intervalMs = 5000;
|
||
const startedAt = Date.now();
|
||
|
||
while (Date.now() - startedAt < timeoutMs) {
|
||
const checks = await Promise.all(
|
||
criticalAssets.map(async (asset) => {
|
||
const assetPath = typeof asset === 'string' ? asset : asset.assetPath;
|
||
const url =
|
||
typeof asset === 'string'
|
||
? `${runtimeCdnBaseUrl}${assetPath}`
|
||
: asset.url || `${runtimeCdnBaseUrl}${assetPath}`;
|
||
const result = await isRemoteAssetReady(url);
|
||
return {
|
||
assetPath,
|
||
url,
|
||
...result,
|
||
};
|
||
})
|
||
);
|
||
|
||
const failed = checks.filter((item) => !item.ok);
|
||
if (failed.length === 0) {
|
||
return {
|
||
ok: true,
|
||
assets: criticalAssets.map((asset) =>
|
||
typeof asset === 'string' ? asset : asset.assetPath
|
||
),
|
||
};
|
||
}
|
||
|
||
const elapsedSec = Math.round((Date.now() - startedAt) / 1000);
|
||
log(
|
||
` 运行时 CDN 关键资源未就绪，${elapsedSec}s 后重试：${failed
|
||
.slice(0, 3)
|
||
.map((item) => `${item.assetPath} -> ${item.url} (${item.reason})`)
|
||
.join(', ')}`,
|
||
'gray'
|
||
);
|
||
await new Promise((resolve) => setTimeout(resolve, intervalMs));
|
||
}
|
||
|
||
return {
|
||
ok: false,
|
||
reason: `等待 ${CONFIG.runtimeCdnProvider} 关键资源就绪超时`,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 检查 npm 包的指定版本是否已存在
|
||
* @param {string} packageName 包名
|
||
* @param {string} version 版本号
|
||
* @returns {{ exists: boolean, checked: boolean, error?: string }} 检查结果
|
||
*/
|
||
function checkNpmVersionExists(packageName, version) {
|
||
const maxAttempts = 2;
|
||
const timeoutMs = 10000;
|
||
|
||
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
|
||
try {
|
||
execSync(
|
||
`npm view ${packageName}@${version} version --registry https://registry.npmjs.org`,
|
||
{
|
||
stdio: 'pipe',
|
||
encoding: 'utf-8',
|
||
timeout: timeoutMs,
|
||
}
|
||
);
|
||
return { exists: true, checked: true };
|
||
} catch (error) {
|
||
const errorMessage = formatExecError(error);
|
||
const isVersionMissing =
|
||
error.status === 1 &&
|
||
/E404|404|not found|No match found/i.test(errorMessage);
|
||
|
||
if (isVersionMissing) {
|
||
return { exists: false, checked: true };
|
||
}
|
||
|
||
const isRetriable =
|
||
error.signal === 'SIGTERM' ||
|
||
/ETIMEDOUT|ECONNRESET|ECONNREFUSED|EAI_AGAIN|ENOTFOUND/i.test(
|
||
errorMessage
|
||
);
|
||
|
||
if (isRetriable && attempt < maxAttempts) {
|
||
logWarning(
|
||
`npm 版本检查失败，第 ${attempt}/${maxAttempts} 次重试中: ${errorMessage}`
|
||
);
|
||
continue;
|
||
}
|
||
|
||
return {
|
||
exists: false,
|
||
checked: false,
|
||
error: errorMessage,
|
||
};
|
||
}
|
||
}
|
||
|
||
return {
|
||
exists: false,
|
||
checked: false,
|
||
error: 'npm 版本检查失败，已达到最大重试次数',
|
||
};
|
||
}
|
||
|
||
function getNextVersion(currentVersion, type = 'patch') {
|
||
const parts = currentVersion.split('.').map(Number);
|
||
if (parts.length !== 3 || parts.some((part) => !Number.isInteger(part))) {
|
||
throw new Error(`版本格式无效: ${currentVersion}`);
|
||
}
|
||
|
||
switch (type) {
|
||
case 'major':
|
||
parts[0]++;
|
||
parts[1] = 0;
|
||
parts[2] = 0;
|
||
break;
|
||
case 'minor':
|
||
parts[1]++;
|
||
parts[2] = 0;
|
||
break;
|
||
case 'patch':
|
||
default:
|
||
parts[2]++;
|
||
break;
|
||
}
|
||
|
||
return parts.join('.');
|
||
}
|
||
|
||
function findNextUnpublishedVersion(currentVersion, bumpType) {
|
||
let nextVersion = getNextVersion(currentVersion, bumpType);
|
||
|
||
while (true) {
|
||
const versionCheck = checkNpmVersionExists(CONFIG.packageName, nextVersion);
|
||
if (!versionCheck.checked) {
|
||
throw new Error(versionCheck.error || `无法检查 npm 版本 ${nextVersion}`);
|
||
}
|
||
if (!versionCheck.exists) {
|
||
return nextVersion;
|
||
}
|
||
|
||
log(
|
||
` npm 已存在 ${CONFIG.packageName}@${nextVersion}，尝试下一个 patch...`,
|
||
'yellow'
|
||
);
|
||
nextVersion = getNextVersion(nextVersion, 'patch');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查是否可以跳过构建
|
||
* 条件：
|
||
* 1. dist/deploy/cdn/precache-manifest.json 存在
|
||
* 2. 版本与当前要构建的版本一致
|
||
* 3. manifest 中的文件都存在于 dist/deploy/cdn 目录
|
||
*
|
||
* @returns {{ canSkip: boolean, reason: string, details?: object }}
|
||
*/
|
||
function checkCanSkipBuild(currentVersion) {
|
||
const manifestPath = path.join(CONFIG.outputCDN, 'precache-manifest.json');
|
||
|
||
// 检查 manifest 是否存在
|
||
if (!fs.existsSync(manifestPath)) {
|
||
return { canSkip: false, reason: 'precache-manifest.json 不存在' };
|
||
}
|
||
|
||
// 读取 manifest
|
||
let manifest;
|
||
try {
|
||
manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
|
||
} catch (error) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `无法解析 precache-manifest.json: ${error.message}`,
|
||
};
|
||
}
|
||
|
||
// 检查版本
|
||
if (manifest.version !== currentVersion) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `版本不匹配 (现有: ${manifest.version}, 目标: ${currentVersion})`,
|
||
};
|
||
}
|
||
|
||
// 检查所有文件是否存在（只检查应该在 CDN 的文件，排除 HTML 等）
|
||
const files = manifest.files || [];
|
||
if (files.length === 0) {
|
||
return { canSkip: false, reason: 'manifest 文件列表为空' };
|
||
}
|
||
|
||
// 过滤出应该在 CDN 的文件
|
||
const cdnFiles = files.filter((file) => {
|
||
const filename = path.basename(file.url);
|
||
return shouldUploadToCDN(filename);
|
||
});
|
||
|
||
if (cdnFiles.length === 0) {
|
||
return { canSkip: false, reason: 'manifest 中没有 CDN 文件' };
|
||
}
|
||
|
||
const missingFiles = [];
|
||
for (const file of cdnFiles) {
|
||
// url 格式如 "/assets/xxx.js"，需要去掉开头的 "/"
|
||
const relativePath = file.url.startsWith('/')
|
||
? file.url.slice(1)
|
||
: file.url;
|
||
const filePath = path.join(CONFIG.outputCDN, relativePath);
|
||
|
||
if (!fs.existsSync(filePath)) {
|
||
missingFiles.push(file.url);
|
||
// 只收集前5个缺失文件用于提示
|
||
if (missingFiles.length >= 5) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (missingFiles.length > 0) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `CDN 目录缺少 ${missingFiles.length}+ 个文件`,
|
||
details: { missingFiles: missingFiles.slice(0, 5) },
|
||
};
|
||
}
|
||
|
||
// 检查 server 目录的 manifest
|
||
const serverManifestPath = path.join(
|
||
CONFIG.outputServer,
|
||
'precache-manifest.json'
|
||
);
|
||
if (!fs.existsSync(serverManifestPath)) {
|
||
return { canSkip: false, reason: 'server/precache-manifest.json 不存在' };
|
||
}
|
||
|
||
// 读取 server manifest
|
||
let serverManifest;
|
||
try {
|
||
serverManifest = JSON.parse(fs.readFileSync(serverManifestPath, 'utf-8'));
|
||
} catch (error) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `无法解析 server/precache-manifest.json: ${error.message}`,
|
||
};
|
||
}
|
||
|
||
// 检查 server 版本
|
||
if (serverManifest.version !== currentVersion) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `server 版本不匹配 (现有: ${serverManifest.version}, 目标: ${currentVersion})`,
|
||
};
|
||
}
|
||
|
||
// 检查 server 文件是否齐全
|
||
const serverFiles = serverManifest.files || [];
|
||
const missingServerFiles = [];
|
||
for (const file of serverFiles) {
|
||
const relativePath = file.url.startsWith('/')
|
||
? file.url.slice(1)
|
||
: file.url;
|
||
const filePath = path.join(CONFIG.outputServer, relativePath);
|
||
|
||
if (!fs.existsSync(filePath)) {
|
||
missingServerFiles.push(file.url);
|
||
if (missingServerFiles.length >= 5) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (missingServerFiles.length > 0) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `server 目录缺少 ${missingServerFiles.length}+ 个文件`,
|
||
details: { missingFiles: missingServerFiles.slice(0, 5) },
|
||
};
|
||
}
|
||
|
||
const criticalAssetsResult = getCriticalCdnAssets(currentVersion);
|
||
if (!criticalAssetsResult.ok) {
|
||
return {
|
||
canSkip: false,
|
||
reason: `入口资源不一致: ${criticalAssetsResult.reason}`,
|
||
};
|
||
}
|
||
|
||
return {
|
||
canSkip: true,
|
||
reason: `版本 ${currentVersion} 已构建完成`,
|
||
details: {
|
||
cdnFileCount: cdnFiles.length,
|
||
serverFileCount: serverFiles.length,
|
||
timestamp: manifest.timestamp,
|
||
},
|
||
};
|
||
}
|
||
|
||
// ============================================
|
||
// 加载服务器配置
|
||
// ============================================
|
||
|
||
function loadEnvConfig() {
|
||
const envPath = path.join(__dirname, '../.env');
|
||
const config = {
|
||
DEPLOY_HOST: '',
|
||
DEPLOY_USER: '',
|
||
DEPLOY_PORT: '22',
|
||
DEPLOY_SSH_KEY: '',
|
||
DEPLOY_SSH_PASSWORD: '',
|
||
DEPLOY_WEB_DIR: '', // 新增：Web 根目录
|
||
};
|
||
|
||
if (fs.existsSync(envPath)) {
|
||
const envContent = fs.readFileSync(envPath, 'utf8');
|
||
envContent.split('\n').forEach((line) => {
|
||
line = line.trim();
|
||
if (line && !line.startsWith('#')) {
|
||
const match = line.match(/^([^=]+)=(.*)$/);
|
||
if (match) {
|
||
const key = match[1].trim();
|
||
let value = match[2].trim();
|
||
if (
|
||
(value.startsWith('"') && value.endsWith('"')) ||
|
||
(value.startsWith("'") && value.endsWith("'"))
|
||
) {
|
||
value = value.slice(1, -1);
|
||
}
|
||
if (config.hasOwnProperty(key)) {
|
||
config[key] = value;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
return config;
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 1: 构建项目
|
||
// ============================================
|
||
|
||
function stepBuild(version) {
|
||
logStep(1, 8, '构建项目');
|
||
|
||
// 显式跳过
|
||
if (skipBuild) {
|
||
logWarning('跳过构建（--skip-build 参数）');
|
||
return true;
|
||
}
|
||
|
||
// 智能跳过：检查现有构建产物
|
||
const buildCheck = checkCanSkipBuild(version);
|
||
if (buildCheck.canSkip) {
|
||
logSuccess(`跳过构建 - ${buildCheck.reason}`);
|
||
if (buildCheck.details) {
|
||
log(
|
||
` CDN: ${buildCheck.details.cdnFileCount} 个文件，Server: ${buildCheck.details.serverFileCount} 个文件`,
|
||
'gray'
|
||
);
|
||
log(` 构建时间: ${buildCheck.details.timestamp}`, 'gray');
|
||
}
|
||
if (
|
||
!exec('node scripts/validate-startup-bundle.js', {
|
||
cwd: path.resolve(__dirname, '..'),
|
||
})
|
||
) {
|
||
logError('启动边界校验失败');
|
||
return false;
|
||
}
|
||
return { skipped: true };
|
||
} else {
|
||
log(` 需要构建: ${buildCheck.reason}`, 'gray');
|
||
if (buildCheck.details?.missingFiles) {
|
||
log(
|
||
` 缺失文件示例: ${buildCheck.details.missingFiles.join(', ')}`,
|
||
'gray'
|
||
);
|
||
}
|
||
}
|
||
|
||
if (!exec('pnpm run build:web', { cwd: path.resolve(__dirname, '..') })) {
|
||
logError('构建失败');
|
||
return false;
|
||
}
|
||
|
||
if (
|
||
!exec('node scripts/validate-startup-bundle.js', {
|
||
cwd: path.resolve(__dirname, '..'),
|
||
})
|
||
) {
|
||
logError('启动边界校验失败');
|
||
return false;
|
||
}
|
||
|
||
logSuccess('构建完成');
|
||
return true;
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 2: E2E 冒烟测试
|
||
// ============================================
|
||
|
||
function stepE2ETest() {
|
||
logStep(2, 8, 'E2E 冒烟测试');
|
||
|
||
if (skipE2E) {
|
||
logWarning('跳过 E2E 测试（--skip-e2e 参数）');
|
||
return true;
|
||
}
|
||
|
||
if (isDryRun) {
|
||
log(` [DRY RUN] 将运行 E2E 冒烟测试`, 'yellow');
|
||
return true;
|
||
}
|
||
|
||
log(' 运行冒烟测试...', 'gray');
|
||
|
||
if (!exec('pnpm run e2e:smoke', { cwd: path.resolve(__dirname, '..') })) {
|
||
logError('E2E 冒烟测试失败');
|
||
logWarning('提示：可使用 --skip-e2e 跳过测试继续部署');
|
||
return false;
|
||
}
|
||
|
||
logSuccess('E2E 冒烟测试通过');
|
||
return true;
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 3: 准备部署文件
|
||
// ============================================
|
||
|
||
function stepSeparateFiles(version, cdnBaseUrl, buildSkipped = false) {
|
||
logStep(3, 8, '准备部署文件');
|
||
|
||
// 如果构建被跳过，文件已经准备好了
|
||
if (buildSkipped) {
|
||
// 快速验证文件是否存在
|
||
const serverExists = fs.existsSync(CONFIG.outputServer);
|
||
const cdnExists = fs.existsSync(CONFIG.outputCDN);
|
||
|
||
if (serverExists && cdnExists) {
|
||
// 统计文件数量
|
||
const countFiles = (dir) => {
|
||
let count = 0;
|
||
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
if (entry.isDirectory()) {
|
||
count += countFiles(path.join(dir, entry.name));
|
||
} else {
|
||
count++;
|
||
}
|
||
}
|
||
return count;
|
||
};
|
||
|
||
const serverCount = countFiles(CONFIG.outputServer);
|
||
const cdnCount = countFiles(CONFIG.outputCDN);
|
||
|
||
logSuccess(`跳过文件准备 - 使用现有产物`);
|
||
log(` 服务器: ${serverCount} 个文件`, 'gray');
|
||
log(` CDN: ${cdnCount} 个文件`, 'gray');
|
||
return true;
|
||
}
|
||
|
||
log(` 现有产物不完整，重新准备文件...`, 'yellow');
|
||
}
|
||
|
||
// 检查构建产物
|
||
if (!fs.existsSync(CONFIG.distDir)) {
|
||
logError(`构建目录不存在: ${CONFIG.distDir}`);
|
||
return false;
|
||
}
|
||
|
||
// 清理输出目录
|
||
if (fs.existsSync(CONFIG.outputServer)) {
|
||
fs.rmSync(CONFIG.outputServer, { recursive: true });
|
||
}
|
||
if (fs.existsSync(CONFIG.outputCDN)) {
|
||
fs.rmSync(CONFIG.outputCDN, { recursive: true });
|
||
}
|
||
ensureDir(CONFIG.outputServer);
|
||
ensureDir(CONFIG.outputCDN);
|
||
|
||
let serverFileCount = 0;
|
||
let cdnFileCount = 0;
|
||
|
||
// 递归复制目录
|
||
function copyDir(src, dest, filter = () => true) {
|
||
ensureDir(dest);
|
||
const entries = fs.readdirSync(src, { withFileTypes: true });
|
||
|
||
for (const entry of entries) {
|
||
const srcPath = path.join(src, entry.name);
|
||
const destPath = path.join(dest, entry.name);
|
||
|
||
if (entry.isDirectory()) {
|
||
copyDir(srcPath, destPath, filter);
|
||
} else if (filter(entry.name)) {
|
||
copyFile(srcPath, destPath);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 服务器：复制全部文件（作为兜底）
|
||
log(' 复制全部文件到服务器目录（兜底）...', 'gray');
|
||
copyDir(CONFIG.distDir, CONFIG.outputServer, (filename) => {
|
||
// 排除 source maps
|
||
if (filename.endsWith('.map')) return false;
|
||
serverFileCount++;
|
||
return true;
|
||
});
|
||
|
||
// CDN：只复制静态资源（不含 HTML）
|
||
log(' 复制静态资源到 CDN 目录...', 'gray');
|
||
copyDir(CONFIG.distDir, CONFIG.outputCDN, (filename) => {
|
||
if (!shouldUploadToCDN(filename)) return false;
|
||
cdnFileCount++;
|
||
return true;
|
||
});
|
||
|
||
// 添加 CDN 版本注释到 HTML（资源路径保持相对，由 SW 处理 CDN 加载）
|
||
const htmlFiles = fs
|
||
.readdirSync(CONFIG.outputServer)
|
||
.filter((f) => f.endsWith('.html'));
|
||
for (const htmlFile of htmlFiles) {
|
||
const htmlPath = path.join(CONFIG.outputServer, htmlFile);
|
||
let content = fs.readFileSync(htmlPath, 'utf-8');
|
||
|
||
// 只添加注释，不修改资源路径（SW 会自动从 CDN 加载并缓存）
|
||
content = content.replace(
|
||
'</head>',
|
||
` <!-- CDN: ${cdnProvider} v${version} | SW handles CDN loading -->\n </head>`
|
||
);
|
||
|
||
fs.writeFileSync(htmlPath, content);
|
||
}
|
||
|
||
logSuccess(`服务器: ${serverFileCount} 个文件（完整副本，用于兜底）`);
|
||
logSuccess(`CDN: ${cdnFileCount} 个静态资源（不含 HTML）`);
|
||
logSuccess(`资源加载：SW 优先 CDN，缓存到 Cache Storage，兜底服务器`);
|
||
return true;
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 4: 发布到 npm CDN
|
||
// ============================================
|
||
|
||
function stepPublishNpm(version) {
|
||
logStep(5, 8, '发布静态资源到 npm CDN');
|
||
|
||
if (skipNpm) {
|
||
logWarning('跳过 npm 发布');
|
||
return true;
|
||
}
|
||
|
||
// 版本检查已在 main 函数开头完成，这里直接发布
|
||
log(` 发布版本: ${CONFIG.packageName}@${version}`, 'gray');
|
||
|
||
// 生成 package.json
|
||
const npmPackage = {
|
||
name: CONFIG.packageName,
|
||
version: version,
|
||
description: 'Opentu static assets for CDN (HTML not included)',
|
||
license: 'MIT',
|
||
files: ['**/*'],
|
||
publishConfig: { access: 'public' },
|
||
aituAssets: { type: 'cdn-assets', htmlIncluded: false },
|
||
};
|
||
|
||
fs.writeFileSync(
|
||
path.join(CONFIG.outputCDN, 'package.json'),
|
||
JSON.stringify(npmPackage, null, 2)
|
||
);
|
||
|
||
// 生成 README
|
||
const readme = `# Opentu CDN Assets v${version}\n\n> 静态资源包，不含 HTML 文件\n\n- unpkg: https://unpkg.com/${CONFIG.packageName}@${version}/\n- jsdelivr: https://cdn.jsdelivr.net/npm/${CONFIG.packageName}@${version}/\n`;
|
||
fs.writeFileSync(path.join(CONFIG.outputCDN, 'README.md'), readme);
|
||
|
||
// 发布
|
||
let publishCmd = `cd "${CONFIG.outputCDN}" && npm publish --access public --registry https://registry.npmjs.org`;
|
||
if (otp) {
|
||
publishCmd += ` --otp=${otp}`;
|
||
}
|
||
|
||
if (isDryRun) {
|
||
log(` [DRY RUN] 将发布: ${CONFIG.packageName}@${version}`, 'yellow');
|
||
return true;
|
||
}
|
||
|
||
if (!exec(publishCmd)) {
|
||
logError('npm 发布失败');
|
||
if (!otp) {
|
||
logWarning('提示：如果启用了 2FA，请使用 --otp=123456 参数');
|
||
}
|
||
return false;
|
||
}
|
||
|
||
logSuccess(`已发布 ${CONFIG.packageName}@${version}`);
|
||
return true;
|
||
}
|
||
|
||
async function stepWaitForCdnReady(version) {
|
||
logStep(6, 8, '等待运行时 CDN 关键资源就绪');
|
||
|
||
if (skipNpm) {
|
||
logWarning('跳过 CDN 就绪等待（未发布 npm 资源）');
|
||
return true;
|
||
}
|
||
|
||
if (isDryRun) {
|
||
log(
|
||
` [DRY RUN] 将等待 ${CONFIG.runtimeCdnProvider} 关键资源 ready`,
|
||
'yellow'
|
||
);
|
||
return true;
|
||
}
|
||
|
||
const result = await waitForRuntimeCdnAssetsReady(version);
|
||
if (!result.ok) {
|
||
logError(result.reason || '运行时 CDN 关键资源未就绪');
|
||
return false;
|
||
}
|
||
|
||
logSuccess(`${CONFIG.runtimeCdnProvider} 关键资源已就绪`);
|
||
return true;
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 5: 部署到服务器（复用 create-deploy-package.js）
|
||
// ============================================
|
||
|
||
function stepDeployServer(version) {
|
||
logStep(7, 8, '打包并部署到服务器');
|
||
|
||
if (skipServer) {
|
||
logWarning('跳过服务器部署');
|
||
return true;
|
||
}
|
||
|
||
if (isDryRun) {
|
||
log(` [DRY RUN] 将调用 create-deploy-package.js 打包并部署`, 'yellow');
|
||
return true;
|
||
}
|
||
|
||
// 调用 create-deploy-package.js 进行打包和部署
|
||
log(' 调用 create-deploy-package.js 打包并部署...', 'gray');
|
||
|
||
try {
|
||
execSync('node scripts/create-deploy-package.js', {
|
||
cwd: path.resolve(__dirname, '..'),
|
||
stdio: 'inherit',
|
||
env: {
|
||
...process.env,
|
||
DEPLOY_PACKAGE_SOURCE_DIR: CONFIG.outputServer,
|
||
},
|
||
});
|
||
logSuccess('打包并部署完成');
|
||
return true;
|
||
} catch (error) {
|
||
logError('打包或部署失败');
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 6: 生成用户手册
|
||
// ============================================
|
||
|
||
function stepGenerateManual(version) {
|
||
logStep(4, 8, '生成用户手册');
|
||
const startTime = Date.now();
|
||
|
||
if (skipManual) {
|
||
logWarning('跳过手册生成（--skip-manual 参数）');
|
||
return true;
|
||
}
|
||
|
||
if (isDryRun) {
|
||
log(` [DRY RUN] 将生成用户手册`, 'yellow');
|
||
return true;
|
||
}
|
||
|
||
// 手册生成不阻塞部署，失败只警告
|
||
try {
|
||
// 步骤 1: 检查端口 7200 是否已被占用，决定截图策略
|
||
let portInUse = false;
|
||
try {
|
||
execSync('lsof -i :7200 -t', { stdio: 'pipe' });
|
||
portInUse = true;
|
||
} catch {
|
||
// 端口未被占用
|
||
}
|
||
|
||
if (portInUse) {
|
||
// 端口已被占用，检查 Playwright 浏览器是否已安装
|
||
let playwrightReady = false;
|
||
try {
|
||
execSync('npx playwright --version', { stdio: 'pipe', timeout: 10000 });
|
||
playwrightReady = true;
|
||
} catch {
|
||
// Playwright 未安装或不可用
|
||
}
|
||
|
||
if (playwrightReady) {
|
||
log(' 📖 手册生成：将更新截图并构建 HTML', 'gray');
|
||
log(
|
||
' 检测到开发服务器已在运行 (端口 7200)，复用现有服务器生成截图',
|
||
'gray'
|
||
);
|
||
|
||
try {
|
||
execSync(
|
||
`cd apps/web-e2e && CI= npx playwright test --project=manual`,
|
||
{
|
||
cwd: path.resolve(__dirname, '..'),
|
||
stdio: 'inherit',
|
||
timeout: 60000, // 1 分钟超时（复用现有服务器，无需等待启动）
|
||
}
|
||
);
|
||
logSuccess('截图生成完成');
|
||
} catch (screenshotError) {
|
||
logWarning('截图生成失败，将使用已有截图继续构建');
|
||
log(` 错误: ${screenshotError.message}`, 'gray');
|
||
}
|
||
} else {
|
||
log(
|
||
' 📖 手册生成：跳过截图（Playwright 浏览器未安装），仅构建 HTML',
|
||
'gray'
|
||
);
|
||
logWarning('Playwright 浏览器未安装，跳过截图生成，使用已有截图');
|
||
log(' 💡 安装命令: npx playwright install chromium', 'gray');
|
||
}
|
||
} else {
|
||
// 端口未被占用，直接跳过截图
|
||
log(' 📖 手册生成：跳过截图，仅构建 HTML', 'gray');
|
||
log(
|
||
' ⏭️ 开发服务器未运行（端口 7200），跳过截图生成，使用已有截图',
|
||
'gray'
|
||
);
|
||
log(' 💡 如需更新截图，请先运行: pnpm manual:screenshots', 'gray');
|
||
}
|
||
|
||
// 步骤 2: 设置 CDN 基础路径环境变量，供 generate-manual.ts 使用
|
||
const cdnBaseUrl = CONFIG.cdnTemplates[cdnProvider].replace(
|
||
'{version}',
|
||
version
|
||
);
|
||
const manualCdnBase = `${cdnBaseUrl}/user-manual`;
|
||
|
||
// 步骤 3: 构建手册 HTML
|
||
log(' 构建手册 HTML...', 'gray');
|
||
try {
|
||
execSync('pnpm run manual:build', {
|
||
cwd: path.resolve(__dirname, '..'),
|
||
stdio: 'inherit',
|
||
env: {
|
||
...process.env,
|
||
MANUAL_CDN_BASE: skipNpm ? '' : manualCdnBase,
|
||
},
|
||
});
|
||
logSuccess('手册 HTML 构建完成');
|
||
} catch (buildError) {
|
||
logWarning('手册 HTML 构建失败（不影响部署）');
|
||
log(` 错误: ${buildError.message}`, 'gray');
|
||
log(' 💡 手动排查: pnpm manual:build', 'gray');
|
||
const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
|
||
log(` ⏱️ 手册生成耗时: ${elapsed} 秒`, 'gray');
|
||
return true; // 不阻塞部署
|
||
}
|
||
|
||
// 复制手册到 dist 目录（构建后手册不会自动包含）
|
||
const manualSourceDir = path.resolve(
|
||
__dirname,
|
||
'../apps/web/public/user-manual'
|
||
);
|
||
const manualDistDir = path.resolve(
|
||
__dirname,
|
||
'../dist/apps/web/user-manual'
|
||
);
|
||
const manualServerDir = path.join(CONFIG.outputServer, 'user-manual');
|
||
const manualCdnDir = path.join(CONFIG.outputCDN, 'user-manual');
|
||
|
||
if (fs.existsSync(manualSourceDir)) {
|
||
// 复制到 dist/apps/web/user-manual
|
||
copyDirRecursive(manualSourceDir, manualDistDir);
|
||
log(` 复制到 dist/apps/web/user-manual`, 'gray');
|
||
|
||
// 复制到 dist/deploy/server/user-manual（HTML + 静态资源，完整副本）
|
||
if (fs.existsSync(CONFIG.outputServer)) {
|
||
copyDirRecursive(manualSourceDir, manualServerDir);
|
||
log(` 复制到 dist/deploy/server/user-manual`, 'gray');
|
||
}
|
||
|
||
// 复制静态资源到 CDN 目录（不含 HTML）
|
||
if (fs.existsSync(CONFIG.outputCDN) && !skipNpm) {
|
||
const screenshotsDir = path.join(manualSourceDir, 'screenshots');
|
||
const gifsDir = path.join(manualSourceDir, 'gifs');
|
||
|
||
if (fs.existsSync(screenshotsDir)) {
|
||
copyDirRecursive(
|
||
screenshotsDir,
|
||
path.join(manualCdnDir, 'screenshots')
|
||
);
|
||
}
|
||
if (fs.existsSync(gifsDir)) {
|
||
copyDirRecursive(gifsDir, path.join(manualCdnDir, 'gifs'));
|
||
}
|
||
|
||
// 统计 CDN 文件数
|
||
let cdnFileCount = 0;
|
||
if (fs.existsSync(manualCdnDir)) {
|
||
cdnFileCount = countFilesRecursive(manualCdnDir);
|
||
}
|
||
log(` 复制 ${cdnFileCount} 个静态资源到 CDN`, 'gray');
|
||
}
|
||
|
||
// 统计文件数
|
||
const fileCount = countFilesRecursive(manualDistDir);
|
||
const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
|
||
logSuccess(`用户手册生成完成 (${fileCount} 个文件，耗时 ${elapsed} 秒)`);
|
||
if (!skipNpm) {
|
||
log(` 静态资源将通过 CDN 加载`, 'gray');
|
||
}
|
||
} else {
|
||
logWarning('手册源目录不存在');
|
||
}
|
||
|
||
return true;
|
||
} catch (error) {
|
||
logWarning('用户手册生成失败（不影响部署）');
|
||
log(` 错误: ${error.message}`, 'gray');
|
||
log(' 💡 手动排查: pnpm manual:build', 'gray');
|
||
const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
|
||
log(` ⏱️ 手册生成耗时: ${elapsed} 秒`, 'gray');
|
||
return true; // 不阻塞部署
|
||
}
|
||
}
|
||
|
||
// 统计目录文件数
|
||
function countFilesRecursive(dir) {
|
||
let count = 0;
|
||
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
if (entry.isDirectory()) {
|
||
count += countFilesRecursive(path.join(dir, entry.name));
|
||
} else {
|
||
count++;
|
||
}
|
||
}
|
||
return count;
|
||
}
|
||
|
||
// 递归复制目录
|
||
function copyDirRecursive(src, dest) {
|
||
if (!fs.existsSync(src)) return;
|
||
|
||
if (!fs.existsSync(dest)) {
|
||
fs.mkdirSync(dest, { recursive: true });
|
||
}
|
||
|
||
const entries = fs.readdirSync(src, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
const srcPath = path.join(src, entry.name);
|
||
const destPath = path.join(dest, entry.name);
|
||
|
||
if (entry.isDirectory()) {
|
||
copyDirRecursive(srcPath, destPath);
|
||
} else {
|
||
fs.copyFileSync(srcPath, destPath);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 步骤 7: 验证部署
|
||
// ============================================
|
||
|
||
function stepVerify(version) {
|
||
logStep(8, 8, '部署完成');
|
||
|
||
log('\n📋 部署摘要', 'cyan');
|
||
log('═'.repeat(50), 'cyan');
|
||
|
||
log('\n🏗️ 架构说明:', 'cyan');
|
||
log(' 用户访问 → 自有服务器（HTML + 静态资源）');
|
||
log(' 静态资源 → 优先 CDN，失败兜底服务器');
|
||
|
||
if (!skipNpm) {
|
||
log(`\n🌐 CDN（静态资源，优先加载）:`, 'green');
|
||
log(` unpkg: https://unpkg.com/${CONFIG.packageName}@${version}/`);
|
||
log(
|
||
` jsdelivr: https://cdn.jsdelivr.net/npm/${CONFIG.packageName}@${version}/`
|
||
);
|
||
log(` ⚠️ CDN 不含 HTML 文件，用户信息安全`);
|
||
}
|
||
|
||
if (!skipServer) {
|
||
const config = loadEnvConfig();
|
||
log(`\n🖥️ 自有服务器:`, 'green');
|
||
if (config.DEPLOY_HOST) {
|
||
log(` ${config.DEPLOY_HOST}`);
|
||
}
|
||
log(` ✓ 通过 create-deploy-package.js 部署`);
|
||
log(` ✓ 完整副本（CDN 失败时兜底）`);
|
||
}
|
||
|
||
if (!skipManual) {
|
||
log(`\n📖 用户手册:`, 'green');
|
||
log(` 部署路径: /user-manual/index.html`);
|
||
log(` 本地预览: dist/apps/web/user-manual/index.html`);
|
||
if (!skipNpm) {
|
||
log(` 静态资源: CDN (截图、GIF 通过 ${cdnProvider} 加载)`);
|
||
} else {
|
||
log(` 静态资源: 服务器（跳过 CDN 发布）`);
|
||
}
|
||
}
|
||
|
||
log('\n🔄 加载顺序:', 'cyan');
|
||
log(' 1. Service Worker 缓存（最快）');
|
||
log(` 2. CDN ${CONFIG.runtimeCdnProvider}（运行时静态资源主链路）`);
|
||
log(' 3. 自有服务器（兜底保障）');
|
||
|
||
if (isDryRun) {
|
||
log('\n⚠️ DRY RUN 模式 - 未实际执行任何操作', 'yellow');
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
// ============================================
|
||
// 主流程
|
||
// ============================================
|
||
|
||
async function main() {
|
||
log('\n' + '═'.repeat(50), 'cyan');
|
||
log('🚀 Opentu 统一混合部署', 'cyan');
|
||
log('═'.repeat(50), 'cyan');
|
||
|
||
if (isDryRun) {
|
||
log('\n⚠️ DRY RUN 模式 - 预览执行，不实际操作\n', 'yellow');
|
||
}
|
||
|
||
let version = getVersion();
|
||
|
||
// 在开始部署前检查版本是否需要升级
|
||
if (!skipNpm) {
|
||
log(
|
||
`\n🔍 检查版本 ${CONFIG.packageName}@${version} 是否已存在于 npm...`,
|
||
'gray'
|
||
);
|
||
const versionCheck = checkNpmVersionExists(CONFIG.packageName, version);
|
||
if (!versionCheck.checked) {
|
||
logError(`无法检查 npm 版本状态: ${versionCheck.error}`);
|
||
logWarning('请检查网络、npm 登录状态，或使用 --skip-npm 跳过 npm 发布');
|
||
process.exit(1);
|
||
}
|
||
|
||
if (versionCheck.exists && isDryRun) {
|
||
log(
|
||
` [DRY RUN] 版本 ${version} 已存在，将执行 ${bumpIfPublished} 版本升级`,
|
||
'yellow'
|
||
);
|
||
} else if (versionCheck.exists) {
|
||
// 版本已存在，需要升级版本
|
||
try {
|
||
const nextVersion = findNextUnpublishedVersion(
|
||
version,
|
||
bumpIfPublished
|
||
);
|
||
log(
|
||
` 版本 ${version} 已存在，升级到 npm 未发布版本 ${nextVersion}`,
|
||
'yellow'
|
||
);
|
||
execSync(`node scripts/safe-version-bump.js ${bumpIfPublished} --target=${nextVersion}`, {
|
||
cwd: path.resolve(__dirname, '..'),
|
||
stdio: 'inherit',
|
||
});
|
||
// 重新获取新版本号
|
||
version = getVersion();
|
||
log(`✅ 版本已升级到: ${version}`, 'green');
|
||
} catch (error) {
|
||
logError('版本升级失败');
|
||
process.exit(1);
|
||
}
|
||
} else {
|
||
log(`✅ 版本 ${version} 不存在于 npm，无需升级`, 'green');
|
||
}
|
||
}
|
||
|
||
const cdnBaseUrl = CONFIG.cdnTemplates[cdnProvider].replace(
|
||
'{version}',
|
||
version
|
||
);
|
||
|
||
log(`\n📦 版本: ${version}`, 'cyan');
|
||
log(`🌐 CDN: ${cdnProvider}`, 'cyan');
|
||
|
||
// 步骤 1: 构建（可能被智能跳过）
|
||
const buildResult = stepBuild(version);
|
||
if (buildResult === false) {
|
||
log('\n❌ 部署失败\n', 'red');
|
||
process.exit(1);
|
||
}
|
||
const buildSkipped = buildResult && buildResult.skipped === true;
|
||
|
||
// 步骤 2: E2E 冒烟测试
|
||
if (!stepE2ETest()) {
|
||
log('\n❌ 部署失败\n', 'red');
|
||
process.exit(1);
|
||
}
|
||
|
||
// 步骤 3-7: 后续流程
|
||
// 注意：手册生成必须在 npm 发布和部署之前执行，否则 CDN 和部署包中不会包含手册
|
||
const steps = [
|
||
() => stepSeparateFiles(version, cdnBaseUrl, buildSkipped),
|
||
() => stepGenerateManual(version), // 必须在 npm 发布之前，确保截图被包含在 CDN
|
||
() => stepPublishNpm(version),
|
||
() => stepWaitForCdnReady(version),
|
||
() => stepDeployServer(version),
|
||
() => stepVerify(version),
|
||
];
|
||
|
||
for (const step of steps) {
|
||
if (!(await step())) {
|
||
log('\n❌ 部署失败\n', 'red');
|
||
process.exit(1);
|
||
}
|
||
}
|
||
|
||
log('\n✅ 部署完成!\n', 'green');
|
||
}
|
||
|
||
if (require.main === module) {
|
||
main().catch((error) => {
|
||
logError(`脚本执行失败: ${error.message}`);
|
||
console.error(error);
|
||
process.exit(1);
|
||
});
|
||
}
|
||
|
||
module.exports = {
|
||
collectEntryAssetReferences,
|
||
getCriticalCdnAssets,
|
||
getRuntimeCdnAssetInfo,
|
||
normalizeAssetPath,
|
||
};
|