cat-shark
498 lines
17 KiB
JavaScript
498 lines
17 KiB
JavaScript
const { spawn } = require('child_process');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const projectRoot = process.cwd();
|
|
const jobsFile = path.resolve(projectRoot, process.argv[2]);
|
|
const sessionDir = path.resolve(projectRoot, process.argv[3]);
|
|
const outputDir = path.join(projectRoot, 'dist-release-final');
|
|
const buildTempDir = path.join(projectRoot, 'build', 'oem-batch-temp');
|
|
const logFile = path.join(sessionDir, 'worker.log');
|
|
const resultFile = path.join(sessionDir, 'result.json');
|
|
const buildOutputFile = path.join(sessionDir, 'build-output.log');
|
|
const stageStatusFile = path.join(sessionDir, 'stage-status.json');
|
|
|
|
let resultWritten = false;
|
|
let lastProgressLogAt = 0;
|
|
const HEARTBEAT_INTERVAL_MS = 30000;
|
|
const liveChildren = new Map();
|
|
|
|
function ensureSessionDir() {
|
|
fs.mkdirSync(sessionDir, { recursive: true });
|
|
fs.mkdirSync(buildTempDir, { recursive: true });
|
|
}
|
|
|
|
function formatError(error) {
|
|
if (!error) return 'Unknown error';
|
|
if (error.stack) return error.stack;
|
|
if (error.message) return error.message;
|
|
return String(error);
|
|
}
|
|
|
|
function writeLog(payload) {
|
|
ensureSessionDir();
|
|
fs.appendFileSync(logFile, JSON.stringify({
|
|
time: new Date().toISOString(),
|
|
...payload,
|
|
}) + '\n', 'utf8');
|
|
}
|
|
|
|
function appendBuildOutput(chunk) {
|
|
ensureSessionDir();
|
|
fs.appendFileSync(buildOutputFile, chunk, 'utf8');
|
|
}
|
|
|
|
function summarizeOutput(text) {
|
|
const lines = String(text || '')
|
|
.split(/\r?\n/)
|
|
.map(line => line.trim())
|
|
.filter(Boolean);
|
|
if (lines.length === 0) return '';
|
|
const lastLine = lines[lines.length - 1];
|
|
return lastLine.length > 700 ? `${lastLine.slice(0, 700)}...` : lastLine;
|
|
}
|
|
|
|
function formatElapsed(ms) {
|
|
const totalSeconds = Math.max(0, Math.floor(ms / 1000));
|
|
const minutes = Math.floor(totalSeconds / 60);
|
|
const seconds = totalSeconds % 60;
|
|
return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
|
|
}
|
|
|
|
function stripAnsi(text) {
|
|
return String(text || '').replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, '');
|
|
}
|
|
|
|
function shouldMirrorOutput(text) {
|
|
const value = stripAnsi(text);
|
|
if (!value.trim()) return false;
|
|
if (/^\s*(Compressing|Processing):\s+/m.test(value)) return false;
|
|
if (/^\s*dist[\\/]/m.test(value)) return false;
|
|
if (/^\s*dist-electron[\\/]/m.test(value)) return false;
|
|
if (!/(error|failed|exception|eperm|eacces|ebusy|enoent|enotempty|cannot|unsafe)/i.test(value)) {
|
|
if (value.includes('\\dist-release-final\\win-unpacked\\resources\\')) return false;
|
|
if (value.includes('/dist-release-final/win-unpacked/resources/')) return false;
|
|
}
|
|
if (value.includes('[plugin:vite:reporter]')) return false;
|
|
if (value.includes('dynamic import will not move module into another chunk')) return false;
|
|
return true;
|
|
}
|
|
|
|
function writeCommandOutputLog(job, level, text) {
|
|
appendBuildOutput(text);
|
|
if (shouldMirrorOutput(text)) {
|
|
writeLog({ jobId: job.id, level, message: text });
|
|
return;
|
|
}
|
|
|
|
const now = Date.now();
|
|
if (now - lastProgressLogAt < 5000) return;
|
|
lastProgressLogAt = now;
|
|
const summary = summarizeOutput(text);
|
|
if (summary) {
|
|
writeLog({ jobId: job.id, level: 'info', message: `[${level}] ${summary}` });
|
|
}
|
|
}
|
|
|
|
function writeResult(payload) {
|
|
ensureSessionDir();
|
|
fs.writeFileSync(resultFile, JSON.stringify(payload, null, 2), 'utf8');
|
|
resultWritten = true;
|
|
}
|
|
|
|
function writeStageStatus(payload) {
|
|
ensureSessionDir();
|
|
fs.writeFileSync(stageStatusFile, JSON.stringify({
|
|
time: new Date().toISOString(),
|
|
...payload,
|
|
}, null, 2), 'utf8');
|
|
}
|
|
|
|
function sanitizeIdentifier(value, fallback) {
|
|
const normalized = String(value || '')
|
|
.trim()
|
|
.replace(/\s+/g, '-')
|
|
.replace(/[^\w.-]/g, '');
|
|
return normalized || fallback;
|
|
}
|
|
|
|
function jsString(value) {
|
|
return JSON.stringify(String(value || ''));
|
|
}
|
|
|
|
function normalizeApiBaseUrl(value) {
|
|
const raw = String(value || '').trim();
|
|
if (!raw) return '';
|
|
const normalized = raw
|
|
.replace(/\/+$/, '')
|
|
.replace(/\/+api$/i, '/api');
|
|
return /\/api$/i.test(normalized) ? normalized : `${normalized}/api`;
|
|
}
|
|
|
|
function validateJob(job) {
|
|
if (!job.brandName || !job.brandName.trim()) {
|
|
throw new Error('Software name is required.');
|
|
}
|
|
job.apiBaseUrl = normalizeApiBaseUrl(job.apiBaseUrl);
|
|
if (!job.apiBaseUrl) {
|
|
throw new Error('API base URL is required.');
|
|
}
|
|
try {
|
|
new URL(job.apiBaseUrl);
|
|
} catch {
|
|
throw new Error(`Invalid API base URL: ${job.apiBaseUrl}`);
|
|
}
|
|
if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(job.version || '')) {
|
|
throw new Error(`Invalid version: ${job.version || '(empty)'}`);
|
|
}
|
|
|
|
const assets = job.assets || {};
|
|
const required = [
|
|
['qrcodePath', 'QR code'],
|
|
['logoPath', 'Logo'],
|
|
['iconPath', 'Icon'],
|
|
['loginBgPath', 'Login background'],
|
|
];
|
|
for (const [key, label] of required) {
|
|
if (!assets[key] || !fs.existsSync(assets[key])) {
|
|
throw new Error(`${label} file does not exist: ${assets[key] || '(empty)'}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
function repairKnownMojibakePath(filePath) {
|
|
return String(filePath || '')
|
|
.replace(/cursor澶囦唤/g, 'cursor备份')
|
|
.replace(/cursor锟斤拷锟斤拷/g, 'cursor备份');
|
|
}
|
|
|
|
function repairJobPaths(job) {
|
|
if (!job.assets) return;
|
|
for (const key of ['qrcodePath', 'logoPath', 'iconPath', 'loginBgPath']) {
|
|
job.assets[key] = repairKnownMojibakePath(job.assets[key]);
|
|
}
|
|
}
|
|
|
|
function copyAssets(job) {
|
|
const assetsDir = path.join(projectRoot, 'oem-assets');
|
|
fs.mkdirSync(assetsDir, { recursive: true });
|
|
fs.copyFileSync(job.assets.qrcodePath, path.join(assetsDir, 'qrcode.png'));
|
|
fs.copyFileSync(job.assets.logoPath, path.join(assetsDir, 'logo.png'));
|
|
fs.copyFileSync(job.assets.iconPath, path.join(assetsDir, 'icon.png'));
|
|
fs.copyFileSync(job.assets.loginBgPath, path.join(assetsDir, 'login-bg.png'));
|
|
}
|
|
|
|
function writeOemConfig(job) {
|
|
const shortName = sanitizeIdentifier(job.brandShortName || job.brandName, 'OEMApp');
|
|
const displayName = job.brandDisplayName && job.brandDisplayName.trim()
|
|
? job.brandDisplayName.trim()
|
|
: job.brandName.trim();
|
|
const slogan = job.brandSlogan && job.brandSlogan.trim() ? job.brandSlogan.trim() : '';
|
|
|
|
const content = `module.exports = {
|
|
appVersion: ${jsString(job.version)},
|
|
|
|
brandName: ${jsString(job.brandName)},
|
|
brandSlogan: ${jsString(slogan)},
|
|
brandShortName: ${jsString(shortName)},
|
|
brandDisplayName: ${jsString(displayName)},
|
|
|
|
qrcodePath: "./oem-assets/qrcode.png",
|
|
logoPath: "./oem-assets/logo.png",
|
|
iconPath: "./oem-assets/icon.png",
|
|
loginBgPath: "./oem-assets/login-bg.png",
|
|
|
|
apiBaseUrl: ${jsString(job.apiBaseUrl)},
|
|
|
|
website: "",
|
|
websiteGithub: "",
|
|
websiteGitee: "",
|
|
};
|
|
`;
|
|
fs.writeFileSync(path.join(projectRoot, 'oem-config.cjs'), content, 'utf8');
|
|
}
|
|
|
|
function listArtifacts(afterMs) {
|
|
if (!fs.existsSync(outputDir)) return [];
|
|
const releaseAssetsDir = path.join(outputDir, 'release-assets');
|
|
const searchRoot = fs.existsSync(releaseAssetsDir) ? releaseAssetsDir : outputDir;
|
|
const files = [];
|
|
const walk = (dir) => {
|
|
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
|
const full = path.join(dir, entry.name);
|
|
if (entry.isDirectory()) {
|
|
if (entry.name === 'win-unpacked') continue;
|
|
walk(full);
|
|
} else if (entry.isFile()) {
|
|
files.push(full);
|
|
}
|
|
}
|
|
};
|
|
walk(searchRoot);
|
|
return files
|
|
.filter(filePath => {
|
|
try {
|
|
const stat = fs.statSync(filePath);
|
|
return stat.isFile() && stat.mtimeMs >= afterMs - 3000;
|
|
} catch {
|
|
return false;
|
|
}
|
|
})
|
|
.filter(filePath => /\.(exe|msi|dmg|zip|7z|blockmap|yml)$/i.test(filePath))
|
|
.sort();
|
|
}
|
|
|
|
function resolveBuildCommand(command) {
|
|
const trimmed = String(command || '').trim();
|
|
const npmRunMatch = /^npm(?:\.cmd)?\s+run\s+([^\s]+)$/i.exec(trimmed);
|
|
if (npmRunMatch) {
|
|
return { file: 'cmd.exe', args: ['/d', '/s', '/c', `npm.cmd run ${npmRunMatch[1]}`], shell: false };
|
|
}
|
|
return { file: 'cmd.exe', args: ['/d', '/s', '/c', trimmed], shell: false };
|
|
}
|
|
|
|
function resolveExternalNsisDir() {
|
|
const nsisDir = 'C:\\Program Files (x86)\\NSIS';
|
|
if (fs.existsSync(path.join(nsisDir, 'Bin', 'makensis.exe'))) {
|
|
return nsisDir;
|
|
}
|
|
return process.env.ELECTRON_BUILDER_NSIS_DIR || '';
|
|
}
|
|
|
|
function runCommand(command, job, label = command) {
|
|
return new Promise((resolve, reject) => {
|
|
const startMs = Date.now();
|
|
lastProgressLogAt = 0;
|
|
const resolved = resolveBuildCommand(command);
|
|
writeStageStatus({ jobId: job.id, stage: label, command, status: 'running', startedAt: new Date().toISOString() });
|
|
writeLog({ jobId: job.id, level: 'info', message: `Run build command: ${label}` });
|
|
writeLog({ jobId: job.id, level: 'info', message: `Spawn: ${resolved.file} ${resolved.args.join(' ')}` });
|
|
|
|
const child = spawn(resolved.file, resolved.args, {
|
|
cwd: projectRoot,
|
|
env: {
|
|
...process.env,
|
|
APP_VERSION: job.version,
|
|
OEM_VERSION: job.version,
|
|
OEM_BATCH_BUILD: '1',
|
|
EXTERNAL_ELECTRON_DEV: '1',
|
|
TEMP: buildTempDir,
|
|
TMP: buildTempDir,
|
|
TMPDIR: buildTempDir,
|
|
ELECTRON_BUILDER_NSIS_DIR: resolveExternalNsisDir(),
|
|
},
|
|
windowsHide: true,
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
shell: resolved.shell,
|
|
});
|
|
if (child.pid) liveChildren.set(child.pid, label);
|
|
|
|
writeLog({ jobId: job.id, level: 'info', message: `Build process pid=${child.pid || 'unknown'}` });
|
|
|
|
const heartbeatTimer = setInterval(() => {
|
|
writeLog({
|
|
jobId: job.id,
|
|
level: 'info',
|
|
message: `Still running: ${label} elapsed ${formatElapsed(Date.now() - startMs)}`,
|
|
});
|
|
}, HEARTBEAT_INTERVAL_MS);
|
|
if (typeof heartbeatTimer.unref === 'function') heartbeatTimer.unref();
|
|
|
|
child.stdout.on('data', data => {
|
|
const text = data.toString();
|
|
writeCommandOutputLog(job, 'stdout', text);
|
|
});
|
|
child.stderr.on('data', data => {
|
|
const text = data.toString();
|
|
writeCommandOutputLog(job, 'stderr', text);
|
|
});
|
|
child.on('error', error => {
|
|
clearInterval(heartbeatTimer);
|
|
if (child.pid) liveChildren.delete(child.pid);
|
|
writeLog({ jobId: job.id, level: 'error', message: `Build process error: ${formatError(error)}` });
|
|
writeStageStatus({ jobId: job.id, stage: label, command, status: 'error', error: formatError(error), finishedAt: new Date().toISOString() });
|
|
reject(error);
|
|
});
|
|
child.on('exit', (code, signal) => {
|
|
writeLog({ jobId: job.id, level: code === 0 ? 'info' : 'error', message: `Build process exit code=${code} signal=${signal || ''}` });
|
|
});
|
|
child.on('close', (code, signal) => {
|
|
clearInterval(heartbeatTimer);
|
|
if (child.pid) liveChildren.delete(child.pid);
|
|
writeLog({ jobId: job.id, level: code === 0 ? 'info' : 'error', message: `Build process close code=${code} signal=${signal || ''}` });
|
|
writeStageStatus({ jobId: job.id, stage: label, command, status: code === 0 ? 'success' : 'failed', code, signal, finishedAt: new Date().toISOString() });
|
|
resolve({ code, signal, artifacts: listArtifacts(startMs) });
|
|
});
|
|
});
|
|
}
|
|
|
|
async function runBuildCommand(command, job) {
|
|
const normalized = String(command || '').trim().toLowerCase();
|
|
if (normalized === 'npm run build:win' || normalized === 'npm.cmd run build:win') {
|
|
const steps = [
|
|
['clean oem package output', 'node scripts/clean-oem-package-output.cjs'],
|
|
['prepare-package', 'node apply-oem.cjs && py -3 scripts/export-runtime-system-templates.py && node scripts/prepare-package.cjs'],
|
|
['build renderer/main/preload', 'node scripts/clean-build-artifacts.cjs && node_modules\\.bin\\vite.cmd build'],
|
|
['build resource artifacts', 'node scripts/build-resource-artifacts.cjs'],
|
|
['make oem builder config', 'node scripts/make-oem-builder-config.cjs'],
|
|
['electron-builder win x64', 'node_modules\\.bin\\electron-builder.cmd --config tools\\oem-batch-builder\\electron-builder.oem.generated.json --win --x64'],
|
|
['hydrate oem portable bundles', 'node scripts/hydrate-oem-portable-bundles.cjs'],
|
|
['build full offline installer', 'node scripts/build-oem-inno-installer.cjs'],
|
|
['assemble release artifacts', 'node scripts/assemble-release-artifacts.cjs'],
|
|
];
|
|
|
|
let artifacts = [];
|
|
for (const [label, stepCommand] of steps) {
|
|
const result = await runCommand(stepCommand, job, label);
|
|
artifacts = result.artifacts || artifacts;
|
|
if (result.code !== 0) {
|
|
return { ...result, artifacts };
|
|
}
|
|
}
|
|
return { code: 0, signal: null, artifacts: listArtifacts(Date.now() - 24 * 60 * 60 * 1000) };
|
|
}
|
|
|
|
return runCommand(command, job);
|
|
}
|
|
|
|
async function runOneJob(rawJob, index) {
|
|
const job = {
|
|
...rawJob,
|
|
id: rawJob.id || `oem-${Date.now()}-${index}`,
|
|
buildCommand: rawJob.buildCommand || 'npm run build:win',
|
|
};
|
|
|
|
writeLog({ jobId: job.id, level: 'info', message: `Prepare ${job.brandName} v${job.version}` });
|
|
repairJobPaths(job);
|
|
validateJob(job);
|
|
copyAssets(job);
|
|
writeOemConfig(job);
|
|
|
|
const { code, signal, artifacts } = await runBuildCommand(job.buildCommand, job);
|
|
const success = code === 0;
|
|
const result = {
|
|
id: job.id,
|
|
brandName: job.brandName,
|
|
version: job.version,
|
|
success,
|
|
code,
|
|
signal,
|
|
outputDir,
|
|
buildOutputFile,
|
|
artifacts,
|
|
message: success ? 'Build finished' : `Build failed, exit code ${code}${signal ? `, signal ${signal}` : ''}`,
|
|
};
|
|
writeLog({ jobId: job.id, level: success ? 'info' : 'error', message: result.message });
|
|
if (artifacts.length > 0) {
|
|
writeLog({ jobId: job.id, level: 'info', message: `Artifacts:\n${artifacts.join('\n')}` });
|
|
}
|
|
return result;
|
|
}
|
|
|
|
process.on('uncaughtException', error => {
|
|
const message = formatError(error);
|
|
try {
|
|
writeLog({ level: 'error', message: `Worker uncaughtException: ${message}` });
|
|
if (!resultWritten) {
|
|
writeResult({
|
|
success: false,
|
|
results: [],
|
|
outputDir,
|
|
buildOutputFile,
|
|
message: `Worker crashed: ${message}`,
|
|
});
|
|
}
|
|
} finally {
|
|
process.exit(1);
|
|
}
|
|
});
|
|
|
|
process.on('unhandledRejection', error => {
|
|
const message = formatError(error);
|
|
writeLog({ level: 'error', message: `Worker unhandledRejection: ${message}` });
|
|
if (!resultWritten) {
|
|
writeResult({
|
|
success: false,
|
|
results: [],
|
|
outputDir,
|
|
buildOutputFile,
|
|
message: `Worker rejected: ${message}`,
|
|
});
|
|
}
|
|
process.exitCode = 1;
|
|
});
|
|
|
|
process.on('exit', code => {
|
|
try {
|
|
writeLog({ level: 'info', message: `Worker exit code=${code} resultWritten=${resultWritten} liveChildren=${JSON.stringify([...liveChildren.entries()])}` });
|
|
} catch {
|
|
// ignore exit logging failure
|
|
}
|
|
if (!resultWritten) {
|
|
try {
|
|
writeResult({
|
|
success: false,
|
|
results: [],
|
|
outputDir,
|
|
buildOutputFile,
|
|
message: `Worker exited before writing a result. Exit code ${code}. See ${logFile}`,
|
|
});
|
|
} catch {
|
|
// Exit handlers cannot reliably recover from filesystem failures.
|
|
}
|
|
}
|
|
});
|
|
|
|
process.on('beforeExit', code => {
|
|
writeLog({ level: 'info', message: `Worker beforeExit code=${code} resultWritten=${resultWritten} liveChildren=${JSON.stringify([...liveChildren.entries()])}` });
|
|
});
|
|
|
|
process.on('SIGTERM', () => {
|
|
writeLog({ level: 'error', message: `Worker received SIGTERM resultWritten=${resultWritten} liveChildren=${JSON.stringify([...liveChildren.entries()])}` });
|
|
});
|
|
|
|
process.on('SIGINT', () => {
|
|
writeLog({ level: 'error', message: `Worker received SIGINT resultWritten=${resultWritten} liveChildren=${JSON.stringify([...liveChildren.entries()])}` });
|
|
});
|
|
|
|
(async () => {
|
|
ensureSessionDir();
|
|
const parsedJobs = JSON.parse(fs.readFileSync(jobsFile, 'utf8').replace(/^\uFEFF/, ''));
|
|
const jobs = Array.isArray(parsedJobs) ? parsedJobs : [parsedJobs];
|
|
const results = [];
|
|
|
|
writeLog({ level: 'info', message: `Batch started, jobs=${jobs.length}` });
|
|
for (let i = 0; i < jobs.length; i++) {
|
|
try {
|
|
results.push(await runOneJob(jobs[i], i));
|
|
} catch (error) {
|
|
const failed = {
|
|
id: jobs[i] && jobs[i].id ? jobs[i].id : `oem-${i}`,
|
|
brandName: jobs[i] && jobs[i].brandName ? jobs[i].brandName : `OEM ${i + 1}`,
|
|
success: false,
|
|
outputDir,
|
|
buildOutputFile,
|
|
artifacts: [],
|
|
message: formatError(error),
|
|
};
|
|
results.push(failed);
|
|
writeLog({ jobId: failed.id, level: 'error', message: failed.message });
|
|
}
|
|
}
|
|
|
|
const payload = { success: results.every(item => item.success), results, outputDir, buildOutputFile };
|
|
writeResult(payload);
|
|
writeLog({ level: 'info', message: 'Batch finished' });
|
|
})().catch(error => {
|
|
const payload = {
|
|
success: false,
|
|
results: [],
|
|
outputDir,
|
|
buildOutputFile,
|
|
message: formatError(error),
|
|
};
|
|
writeResult(payload);
|
|
writeLog({ level: 'error', message: payload.message });
|
|
process.exitCode = 1;
|
|
});
|