wehub-resource-sync
917 lines
34 KiB
JavaScript
917 lines
34 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
/**
|
||
* Simplified build script for AionUi
|
||
* Coordinates electron-vite (bundling) and electron-builder (packaging)
|
||
*
|
||
* Features:
|
||
* - Incremental builds: use --skip-vite to skip Vite compilation if out/ exists
|
||
* - Skip native rebuild: use --skip-native to skip native module rebuilding
|
||
* - Packaging only: use --pack-only to skip electron-builder distributable creation
|
||
*/
|
||
|
||
const { execSync, spawnSync } = require('child_process');
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
const crypto = require('crypto');
|
||
|
||
// DMG retry logic for macOS: detects DMG creation failures by checking artifacts
|
||
// (.app exists but .dmg missing) and retries only the DMG step using
|
||
// electron-builder --prepackaged with the .app path (not the parent directory).
|
||
// This preserves full DMG styling (window size, icon positions, background)
|
||
// Background: GitHub Actions macos-14 runners occasionally suffer from transient
|
||
// "Device not configured" hdiutil errors (electron-builder#8415, actions/runner-images#12323).
|
||
const DMG_RETRY_MAX = 3;
|
||
const DMG_RETRY_DELAY_SEC = 30;
|
||
|
||
// Incremental build: hash of source files to detect changes
|
||
const INCREMENTAL_CACHE_FILE = 'out/.build-hash';
|
||
const DEBUG_AUTO_UPDATE_CURRENT_VERSION_ENV = 'AIONUI_DEBUG_AUTO_UPDATE_CURRENT_VERSION';
|
||
|
||
function patchElectronBuilderNsisInstaller() {
|
||
const rootDir = path.resolve(__dirname, '..');
|
||
let appBuilderDir = '';
|
||
try {
|
||
appBuilderDir = path.dirname(require.resolve('app-builder-lib/package.json'));
|
||
} catch (error) {
|
||
const bunModulesDir = path.join(rootDir, 'node_modules', '.bun');
|
||
if (fs.existsSync(bunModulesDir)) {
|
||
const candidates = fs
|
||
.readdirSync(bunModulesDir, { withFileTypes: true })
|
||
.filter((entry) => entry.isDirectory() && entry.name.startsWith('app-builder-lib@'))
|
||
.map((entry) => path.join(bunModulesDir, entry.name, 'node_modules', 'app-builder-lib'))
|
||
.filter((candidate) => fs.existsSync(path.join(candidate, 'package.json')))
|
||
.sort();
|
||
appBuilderDir = candidates[0] || '';
|
||
}
|
||
if (!appBuilderDir) {
|
||
console.warn(`Warning: app-builder-lib is not resolvable; skipping NSIS template patch: ${error.message}`);
|
||
return;
|
||
}
|
||
}
|
||
|
||
const installUtilPath = path.join(appBuilderDir, 'templates', 'nsis', 'include', 'installUtil.nsh');
|
||
if (!fs.existsSync(installUtilPath)) {
|
||
console.warn(`Warning: electron-builder NSIS installUtil.nsh not found: ${installUtilPath}`);
|
||
return;
|
||
}
|
||
|
||
const original = fs.readFileSync(installUtilPath, 'utf8');
|
||
let patched = original;
|
||
|
||
const retryPrompt = [
|
||
' ${if} $R5 > 5',
|
||
' MessageBox MB_RETRYCANCEL|MB_ICONEXCLAMATION "$(appCannotBeClosed)" /SD IDCANCEL IDRETRY OneMoreAttempt',
|
||
' Return',
|
||
' ${endIf}',
|
||
].join('\n');
|
||
const retryHandoff = [
|
||
' ${if} $R5 > 5',
|
||
' DetailPrint `Previous uninstaller did not finish after retry limit; deferring to customUnInstallCheck.`',
|
||
' Return',
|
||
' ${endIf}',
|
||
].join('\n');
|
||
|
||
if (patched.includes(retryPrompt)) {
|
||
patched = patched.replace(retryPrompt, retryHandoff);
|
||
} else if (!patched.includes(retryHandoff)) {
|
||
throw new Error(
|
||
'electron-builder NSIS uninstall retry prompt template changed; update patchElectronBuilderNsisInstaller.'
|
||
);
|
||
}
|
||
|
||
const oneMoreAttemptLabel = ' OneMoreAttempt:\n';
|
||
if (patched.includes(oneMoreAttemptLabel)) {
|
||
patched = patched.replace(oneMoreAttemptLabel, '');
|
||
}
|
||
|
||
const copiedUninstallerExec = `ExecWait '"$uninstallerFileNameTemp" /S /KEEP_APP_DATA $0 _?=$installationDir' $R0`;
|
||
const copiedUninstallerExecWithLog = `ExecWait '"$uninstallerFileNameTemp" /S /KEEP_APP_DATA $0 --installer-log="$AionUiSessionLogPath" --installer-session="$AionUiSessionId" _?=$installationDir' $R0`;
|
||
if (patched.includes(copiedUninstallerExec)) {
|
||
patched = patched.replace(copiedUninstallerExec, copiedUninstallerExecWithLog);
|
||
} else if (
|
||
patched.includes(
|
||
`ExecWait '"$uninstallerFileNameTemp" /S /KEEP_APP_DATA $0 --installer-log="$AionUiSessionLogPath" _?=$installationDir' $R0`
|
||
)
|
||
) {
|
||
patched = patched.replace(
|
||
`ExecWait '"$uninstallerFileNameTemp" /S /KEEP_APP_DATA $0 --installer-log="$AionUiSessionLogPath" _?=$installationDir' $R0`,
|
||
copiedUninstallerExecWithLog
|
||
);
|
||
} else if (!patched.includes(copiedUninstallerExecWithLog)) {
|
||
throw new Error(
|
||
'electron-builder copied-uninstaller ExecWait template changed; update patchElectronBuilderNsisInstaller.'
|
||
);
|
||
}
|
||
|
||
const uninstallerCopySource = [
|
||
' StrCpy $uninstallerFileNameTemp "$PLUGINSDIR\\old-uninstaller.exe"',
|
||
' !insertmacro copyFile "$uninstallerFileName" "$uninstallerFileNameTemp"',
|
||
].join('\n');
|
||
const bundledUninstallerOverride = [
|
||
' ${if} ${FileExists} "$PLUGINSDIR\\AionUi-fixed-uninstaller.exe"',
|
||
' DetailPrint `AionUi-bundled-uninstaller override source.`',
|
||
' StrCpy $uninstallerFileName "$PLUGINSDIR\\AionUi-fixed-uninstaller.exe"',
|
||
' ${endIf}',
|
||
].join('\n');
|
||
const bundledUninstallerCopySource = [
|
||
bundledUninstallerOverride,
|
||
'',
|
||
' StrCpy $uninstallerFileNameTemp "$PLUGINSDIR\\old-uninstaller.exe"',
|
||
' !insertmacro copyFile "$uninstallerFileName" "$uninstallerFileNameTemp"',
|
||
].join('\n');
|
||
|
||
while (patched.includes(`${bundledUninstallerOverride}\n\n${bundledUninstallerOverride}`)) {
|
||
patched = patched.replace(
|
||
`${bundledUninstallerOverride}\n\n${bundledUninstallerOverride}`,
|
||
bundledUninstallerOverride
|
||
);
|
||
}
|
||
|
||
if (patched.includes(bundledUninstallerOverride)) {
|
||
// Already patched.
|
||
} else if (patched.includes(uninstallerCopySource)) {
|
||
patched = patched.replace(uninstallerCopySource, bundledUninstallerCopySource);
|
||
} else {
|
||
throw new Error(
|
||
'electron-builder old-uninstaller copy template changed; update patchElectronBuilderNsisInstaller.'
|
||
);
|
||
}
|
||
|
||
const inPlaceUninstallerExec = `ExecWait '"$uninstallerFileName" /S /KEEP_APP_DATA $0 _?=$installationDir' $R0`;
|
||
const inPlaceUninstallerExecWithLog = `ExecWait '"$uninstallerFileName" /S /KEEP_APP_DATA $0 --installer-log="$AionUiSessionLogPath" --installer-session="$AionUiSessionId" _?=$installationDir' $R0`;
|
||
if (patched.includes(inPlaceUninstallerExec)) {
|
||
patched = patched.replace(inPlaceUninstallerExec, inPlaceUninstallerExecWithLog);
|
||
} else if (
|
||
patched.includes(
|
||
`ExecWait '"$uninstallerFileName" /S /KEEP_APP_DATA $0 --installer-log="$AionUiSessionLogPath" _?=$installationDir' $R0`
|
||
)
|
||
) {
|
||
patched = patched.replace(
|
||
`ExecWait '"$uninstallerFileName" /S /KEEP_APP_DATA $0 --installer-log="$AionUiSessionLogPath" _?=$installationDir' $R0`,
|
||
inPlaceUninstallerExecWithLog
|
||
);
|
||
} else if (!patched.includes(inPlaceUninstallerExecWithLog)) {
|
||
throw new Error(
|
||
'electron-builder in-place uninstaller ExecWait template changed; update patchElectronBuilderNsisInstaller.'
|
||
);
|
||
}
|
||
|
||
if (patched !== original) {
|
||
fs.writeFileSync(installUtilPath, patched);
|
||
console.log('Patched electron-builder NSIS uninstall failure handoff.');
|
||
}
|
||
}
|
||
|
||
function walkFiles(dir, acc = []) {
|
||
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
||
for (const entry of entries) {
|
||
const fullPath = path.join(dir, entry.name);
|
||
if (entry.isDirectory()) {
|
||
if (entry.name === 'node_modules' || entry.name === 'out' || entry.name === '.git') continue;
|
||
walkFiles(fullPath, acc);
|
||
} else if (entry.isFile()) {
|
||
acc.push(fullPath);
|
||
}
|
||
}
|
||
return acc;
|
||
}
|
||
|
||
function computeSourceHash() {
|
||
const hash = crypto.createHash('md5');
|
||
const rootDir = path.resolve(__dirname, '..');
|
||
const filesToHash = [
|
||
'package.json',
|
||
'package-lock.json',
|
||
'bun.lock',
|
||
'tsconfig.json',
|
||
'packages/desktop/electron.vite.config.ts',
|
||
'packages/desktop/electron-builder.yml',
|
||
'justfile',
|
||
];
|
||
|
||
for (const file of filesToHash) {
|
||
const filePath = path.resolve(rootDir, file);
|
||
if (fs.existsSync(filePath)) {
|
||
const content = fs.readFileSync(filePath);
|
||
hash.update(file + ':');
|
||
hash.update(content);
|
||
}
|
||
}
|
||
|
||
const hashDirs = ['packages/desktop/src', 'packages', 'public', 'scripts'];
|
||
for (const dir of hashDirs) {
|
||
const dirPath = path.resolve(rootDir, dir);
|
||
if (!fs.existsSync(dirPath)) continue;
|
||
|
||
const files = walkFiles(dirPath)
|
||
.map((file) => path.relative(rootDir, file).replace(/\\/g, '/'))
|
||
.sort();
|
||
|
||
for (const relPath of files) {
|
||
const absolutePath = path.resolve(rootDir, relPath);
|
||
const stat = fs.statSync(absolutePath);
|
||
hash.update(relPath + ':');
|
||
hash.update(String(stat.size));
|
||
hash.update(String(stat.mtimeMs));
|
||
}
|
||
}
|
||
|
||
return hash.digest('hex');
|
||
}
|
||
|
||
function loadCachedHash() {
|
||
try {
|
||
const cacheFile = path.resolve(__dirname, '..', INCREMENTAL_CACHE_FILE);
|
||
if (fs.existsSync(cacheFile)) {
|
||
return fs.readFileSync(cacheFile, 'utf8').trim();
|
||
}
|
||
} catch {}
|
||
return null;
|
||
}
|
||
|
||
function saveCurrentHash(hash) {
|
||
try {
|
||
const cacheFile = path.resolve(__dirname, '..', INCREMENTAL_CACHE_FILE);
|
||
const viteDir = path.dirname(cacheFile);
|
||
if (!fs.existsSync(viteDir)) {
|
||
fs.mkdirSync(viteDir, { recursive: true });
|
||
}
|
||
fs.writeFileSync(cacheFile, hash);
|
||
} catch {}
|
||
}
|
||
|
||
function viteBuildExists() {
|
||
const outDir = path.resolve(__dirname, '../out');
|
||
const mainDir = path.join(outDir, 'main');
|
||
const rendererDir = path.join(outDir, 'renderer');
|
||
|
||
return (
|
||
fs.existsSync(path.join(mainDir, 'index.js')) &&
|
||
fs.existsSync(path.join(outDir, 'preload', 'index.js')) &&
|
||
validateRendererBuildOutput(rendererDir).valid
|
||
);
|
||
}
|
||
|
||
function collectHtmlAssetRefs(html, htmlDirRelative) {
|
||
const refs = [];
|
||
const attrRe = /\b(?:src|href)=["']([^"']+)["']/g;
|
||
for (const match of html.matchAll(attrRe)) {
|
||
const rawRef = match[1];
|
||
if (!rawRef || rawRef.startsWith('http:') || rawRef.startsWith('https:') || rawRef.startsWith('data:')) continue;
|
||
if (!rawRef.startsWith('./') && !rawRef.startsWith('../')) continue;
|
||
|
||
const normalized = path
|
||
.normalize(path.join(htmlDirRelative, rawRef.split(/[?#]/)[0]))
|
||
.replace(/\\/g, '/')
|
||
.replace(/^\.\//, '');
|
||
if (normalized.startsWith('assets/')) {
|
||
refs.push(normalized);
|
||
}
|
||
}
|
||
return refs;
|
||
}
|
||
|
||
function walkHtmlFiles(dir, baseDir = dir, acc = []) {
|
||
if (!fs.existsSync(dir)) return acc;
|
||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||
const fullPath = path.join(dir, entry.name);
|
||
if (entry.isDirectory()) {
|
||
walkHtmlFiles(fullPath, baseDir, acc);
|
||
} else if (entry.isFile() && entry.name.endsWith('.html')) {
|
||
acc.push({
|
||
fullPath,
|
||
relativePath: path.relative(baseDir, fullPath).replace(/\\/g, '/'),
|
||
});
|
||
}
|
||
}
|
||
return acc;
|
||
}
|
||
|
||
function validateRendererBuildOutput(rendererDir) {
|
||
const problems = [];
|
||
const indexHtmlPath = path.join(rendererDir, 'index.html');
|
||
if (!fs.existsSync(indexHtmlPath)) {
|
||
return { valid: false, problems: ['Renderer build output is incomplete: missing out/renderer/index.html'] };
|
||
}
|
||
|
||
const htmlFiles = walkHtmlFiles(rendererDir);
|
||
if (htmlFiles.length === 0) {
|
||
return { valid: false, problems: ['Renderer build output is incomplete: no HTML files under out/renderer'] };
|
||
}
|
||
|
||
const assetRefs = new Set();
|
||
for (const htmlFile of htmlFiles) {
|
||
const html = fs.readFileSync(htmlFile.fullPath, 'utf8');
|
||
if (/src=["'][^"']*\.tsx(?:[?#][^"']*)?["']/.test(html)) {
|
||
problems.push(`Renderer build output is incomplete: ${htmlFile.relativePath} still references TypeScript source`);
|
||
}
|
||
|
||
const htmlDirRelative = path.dirname(htmlFile.relativePath);
|
||
const baseRelative = htmlDirRelative === '.' ? '' : htmlDirRelative;
|
||
for (const ref of collectHtmlAssetRefs(html, baseRelative)) {
|
||
assetRefs.add(ref);
|
||
}
|
||
}
|
||
|
||
const indexHtml = fs.readFileSync(indexHtmlPath, 'utf8');
|
||
if (!/<div\s+id=["']root["']/.test(indexHtml)) {
|
||
problems.push('Renderer build output is incomplete: index.html is missing #root');
|
||
}
|
||
if (!/<script\b[^>]*type=["']module["'][^>]*\bsrc=["']\.\/assets\/[^"']+\.js["']/.test(indexHtml)) {
|
||
problems.push('Renderer build output is incomplete: index.html has no bundled module script');
|
||
}
|
||
|
||
if (assetRefs.size === 0) {
|
||
problems.push('Renderer build output is incomplete: no bundled renderer asset references found');
|
||
}
|
||
|
||
for (const ref of [...assetRefs].sort()) {
|
||
if (!fs.existsSync(path.join(rendererDir, ref))) {
|
||
problems.push(`Renderer build output is incomplete: missing referenced asset ${ref}`);
|
||
}
|
||
}
|
||
|
||
return { valid: problems.length === 0, problems };
|
||
}
|
||
|
||
function validateViteBuildOutput() {
|
||
const outDir = path.resolve(__dirname, '../out');
|
||
const problems = [];
|
||
|
||
for (const relPath of ['main/index.js', 'preload/index.js']) {
|
||
if (!fs.existsSync(path.join(outDir, relPath))) {
|
||
problems.push(`Vite build output is incomplete: missing out/${relPath}`);
|
||
}
|
||
}
|
||
|
||
const rendererValidation = validateRendererBuildOutput(path.join(outDir, 'renderer'));
|
||
problems.push(...rendererValidation.problems);
|
||
|
||
return { valid: problems.length === 0, problems };
|
||
}
|
||
|
||
function shouldSkipViteBuild(skipViteFlag, forceFlag) {
|
||
if (forceFlag) return false;
|
||
if (skipViteFlag) return true;
|
||
|
||
// Auto-detect: skip if build exists and hash matches
|
||
const currentHash = computeSourceHash();
|
||
const cachedHash = loadCachedHash();
|
||
|
||
if (cachedHash && currentHash === cachedHash && viteBuildExists()) {
|
||
console.log('📦 Incremental build: Vite output unchanged, skipping compilation');
|
||
return true;
|
||
}
|
||
|
||
if (cachedHash && currentHash === cachedHash) {
|
||
const validation = validateViteBuildOutput();
|
||
if (!validation.valid) {
|
||
console.warn('Incremental build cache matched but output is incomplete; rebuilding.');
|
||
for (const problem of validation.problems.slice(0, 5)) {
|
||
console.warn(` ${problem}`);
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
function cleanupDiskImages() {
|
||
try {
|
||
// Detach all mounted disk images that may block subsequent DMG creation:
|
||
// hdiutil info → grep device paths → force detach each
|
||
const result = spawnSync(
|
||
'sh',
|
||
[
|
||
'-c',
|
||
"hdiutil info 2>/dev/null | grep /dev/disk | awk '{print $1}' | xargs -I {} hdiutil detach {} -force 2>/dev/null",
|
||
],
|
||
{ stdio: 'ignore' }
|
||
);
|
||
if (result.status !== 0) {
|
||
console.log(` ℹ️ Disk image cleanup exit code: ${result.status}`);
|
||
}
|
||
return result.status === 0;
|
||
} catch (error) {
|
||
console.log(` ℹ️ Disk image cleanup failed: ${error.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Find the .app directory from electron-builder output
|
||
function findAppDir(outDir) {
|
||
const candidates = ['mac', 'mac-arm64', 'mac-x64', 'mac-universal'];
|
||
for (const dir of candidates) {
|
||
const fullPath = path.join(outDir, dir);
|
||
if (fs.existsSync(fullPath)) {
|
||
const hasApp = fs.readdirSync(fullPath).some((f) => f.endsWith('.app'));
|
||
if (hasApp) return fullPath;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// Check if DMG exists in output directory
|
||
function dmgExists(outDir) {
|
||
try {
|
||
return fs.readdirSync(outDir).some((f) => f.endsWith('.dmg'));
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function tryRemoveDir(targetDir) {
|
||
if (!fs.existsSync(targetDir)) return true;
|
||
try {
|
||
fs.rmSync(targetDir, {
|
||
recursive: true,
|
||
force: true,
|
||
maxRetries: 5,
|
||
retryDelay: 300,
|
||
});
|
||
return true;
|
||
} catch (error) {
|
||
console.log(`❌ Failed to remove ${targetDir}: ${error.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function isProcessRunningWindows(imageName) {
|
||
if (process.platform !== 'win32') return false;
|
||
try {
|
||
const result = execSync(`tasklist /FI "IMAGENAME eq ${imageName}"`, {
|
||
stdio: ['ignore', 'pipe', 'ignore'],
|
||
});
|
||
return result.toString().toLowerCase().includes(imageName.toLowerCase());
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function killWindowsProcesses(imageNames) {
|
||
if (process.platform !== 'win32') return;
|
||
for (const name of imageNames) {
|
||
try {
|
||
execSync(`taskkill /F /IM ${name}`, { stdio: 'ignore' });
|
||
} catch {}
|
||
}
|
||
}
|
||
|
||
function formatExecError(error) {
|
||
return [error?.message, error?.stdout?.toString?.(), error?.stderr?.toString?.()].filter(Boolean).join('\n').trim();
|
||
}
|
||
|
||
function escapeNsisDefineValue(value) {
|
||
return String(value ?? '')
|
||
.replace(/\\/g, '\\\\')
|
||
.replace(/"/g, '$\\"');
|
||
}
|
||
|
||
function writeGeneratedSentryDsnInclude(projectRoot) {
|
||
const generatedInclude = path.join(projectRoot, 'resources/windows/support/_sentry-dsn.generated.nsh');
|
||
fs.mkdirSync(path.dirname(generatedInclude), { recursive: true });
|
||
fs.writeFileSync(
|
||
generatedInclude,
|
||
`!define AIONUI_SENTRY_DSN "${escapeNsisDefineValue(process.env.SENTRY_DSN || '')}"\n`
|
||
);
|
||
}
|
||
|
||
function isValidPackageVersion(value) {
|
||
return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(
|
||
value
|
||
);
|
||
}
|
||
|
||
function applyDebugAutoUpdateVersionOverride(packageJsonPath) {
|
||
const debugAutoUpdateCurrentVersion = process.env[DEBUG_AUTO_UPDATE_CURRENT_VERSION_ENV]?.trim();
|
||
if (!debugAutoUpdateCurrentVersion) {
|
||
return () => {};
|
||
}
|
||
if (!isValidPackageVersion(debugAutoUpdateCurrentVersion)) {
|
||
throw new Error(`${DEBUG_AUTO_UPDATE_CURRENT_VERSION_ENV} must be a valid semver version`);
|
||
}
|
||
|
||
const originalPackageJsonText = fs.readFileSync(packageJsonPath, 'utf8');
|
||
const packageJson = JSON.parse(originalPackageJsonText);
|
||
const originalPackageVersion = packageJson.version;
|
||
if (originalPackageVersion === debugAutoUpdateCurrentVersion) {
|
||
console.log(`Debug auto-update build version already set to ${debugAutoUpdateCurrentVersion}`);
|
||
return () => {};
|
||
}
|
||
|
||
packageJson.version = debugAutoUpdateCurrentVersion;
|
||
fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
|
||
console.log(
|
||
`Debug auto-update build version override: ${originalPackageVersion} -> ${debugAutoUpdateCurrentVersion}`
|
||
);
|
||
|
||
return () => {
|
||
if (fs.readFileSync(packageJsonPath, 'utf8') !== originalPackageJsonText) {
|
||
fs.writeFileSync(packageJsonPath, originalPackageJsonText);
|
||
console.log(`Restored package.json version to ${originalPackageVersion}`);
|
||
}
|
||
};
|
||
}
|
||
|
||
// Create macOS distributables using electron-builder --prepackaged with .app path.
|
||
// This preserves DMG styling and still emits the zip required by MacUpdater.
|
||
function createMacArtifactsWithPrepackaged(appDir, targetArch) {
|
||
const appName = fs.readdirSync(appDir).find((f) => f.endsWith('.app'));
|
||
if (!appName) throw new Error(`No .app found in ${appDir}`);
|
||
const appPath = path.join(appDir, appName);
|
||
|
||
execSync(
|
||
`bunx electron-builder --config packages/desktop/electron-builder.yml --mac dmg zip --${targetArch} --prepackaged "${appPath}" --publish=never`,
|
||
{
|
||
stdio: 'inherit',
|
||
shell: process.platform === 'win32',
|
||
}
|
||
);
|
||
}
|
||
|
||
function buildWithDmgRetry(cmd, targetArch) {
|
||
const isMac = process.platform === 'darwin';
|
||
const outDir = path.resolve(__dirname, '../out');
|
||
|
||
try {
|
||
execSync(cmd, { stdio: 'inherit', shell: process.platform === 'win32' });
|
||
return;
|
||
} catch (error) {
|
||
// On non-macOS or if .app doesn't exist, just throw
|
||
const appDir = isMac ? findAppDir(outDir) : null;
|
||
if (!appDir || dmgExists(outDir)) throw error;
|
||
|
||
// .app exists but no .dmg → DMG creation failed
|
||
console.log('\n🔄 Build failed during DMG creation (.app exists, .dmg missing)');
|
||
console.log(' Retrying macOS distributable creation with --prepackaged...');
|
||
|
||
for (let attempt = 1; attempt <= DMG_RETRY_MAX; attempt++) {
|
||
cleanupDiskImages();
|
||
spawnSync('sleep', [String(DMG_RETRY_DELAY_SEC)]);
|
||
|
||
try {
|
||
console.log(`\n📀 DMG retry attempt ${attempt}/${DMG_RETRY_MAX}...`);
|
||
createMacArtifactsWithPrepackaged(appDir, targetArch);
|
||
console.log('✅ macOS distributables created successfully on retry');
|
||
return;
|
||
} catch (retryError) {
|
||
console.log(` ⚠️ DMG retry ${attempt}/${DMG_RETRY_MAX} failed`);
|
||
cleanupDiskImages();
|
||
if (attempt === DMG_RETRY_MAX) {
|
||
console.log(` ❌ DMG creation failed after ${DMG_RETRY_MAX} retries`);
|
||
throw retryError;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Clean stale Windows packaging outputs from previous runs
|
||
function cleanupWindowsPackOutput() {
|
||
const outDir = path.resolve(__dirname, '../out');
|
||
if (!fs.existsSync(outDir)) return;
|
||
|
||
const removed = [];
|
||
const winUnpackedDirRe = /^win(?:-[a-z0-9]+)?-unpacked$/i;
|
||
const winArtifactFileRe = /-win-[^.]+\.(?:exe|msi|zip|7z)$/i;
|
||
|
||
for (const entry of fs.readdirSync(outDir, { withFileTypes: true })) {
|
||
const fullPath = path.join(outDir, entry.name);
|
||
|
||
if (entry.isDirectory() && winUnpackedDirRe.test(entry.name)) {
|
||
fs.rmSync(fullPath, { recursive: true, force: true });
|
||
removed.push(entry.name);
|
||
continue;
|
||
}
|
||
|
||
if (entry.isFile() && winArtifactFileRe.test(entry.name)) {
|
||
fs.rmSync(fullPath, { force: true });
|
||
removed.push(entry.name);
|
||
}
|
||
}
|
||
|
||
if (removed.length > 0) {
|
||
console.log(`🧹 Cleaned stale Windows outputs: ${removed.join(', ')}`);
|
||
}
|
||
}
|
||
|
||
// Parse command line arguments
|
||
const args = process.argv.slice(2);
|
||
const archList = ['x64', 'arm64', 'ia32', 'armv7l'];
|
||
|
||
// Check for special flags
|
||
const skipVite = args.includes('--skip-vite');
|
||
const skipNative = args.includes('--skip-native');
|
||
const packOnly = args.includes('--pack-only');
|
||
const forceBuild = args.includes('--force');
|
||
|
||
const builderArgs = args
|
||
.filter((arg) => {
|
||
// Filter out 'auto', architecture flags, and special flags
|
||
if (arg === 'auto') return false;
|
||
if (arg === '--skip-vite' || arg === '--skip-native' || arg === '--pack-only' || arg === '--force') return false;
|
||
if (archList.includes(arg)) return false;
|
||
if (arg.startsWith('--') && archList.includes(arg.slice(2))) return false;
|
||
return true;
|
||
})
|
||
.join(' ');
|
||
|
||
// Get target architecture from electron-builder.yml
|
||
function getTargetArchFromConfig(platform) {
|
||
try {
|
||
const configPath = path.resolve(__dirname, '../packages/desktop/electron-builder.yml');
|
||
const content = fs.readFileSync(configPath, 'utf8');
|
||
|
||
const platformRegex = new RegExp(`^${platform}:\\s*$`, 'm');
|
||
const platformMatch = content.match(platformRegex);
|
||
if (!platformMatch) return null;
|
||
|
||
const platformStartIndex = platformMatch.index;
|
||
const afterPlatform = content.slice(platformStartIndex + platformMatch[0].length);
|
||
const nextPlatformMatch = afterPlatform.match(/^[a-zA-Z][a-zA-Z0-9]*:/m);
|
||
const platformBlock = nextPlatformMatch
|
||
? content.slice(platformStartIndex, platformStartIndex + platformMatch[0].length + nextPlatformMatch.index)
|
||
: content.slice(platformStartIndex);
|
||
|
||
const archMatch = platformBlock.match(/arch:\s*\[\s*([a-z0-9_]+)/i);
|
||
return archMatch ? archMatch[1].trim() : null;
|
||
} catch (error) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// Determine target architecture
|
||
const buildMachineArch = process.arch;
|
||
let targetArch;
|
||
let multiArch = false;
|
||
|
||
// Check if multiple architectures are specified (support both --x64 and x64 formats)
|
||
const rawArchArgs = args
|
||
.filter((arg) => {
|
||
if (archList.includes(arg)) return true;
|
||
if (arg.startsWith('--') && archList.includes(arg.slice(2))) return true;
|
||
return false;
|
||
})
|
||
.map((arg) => (arg.startsWith('--') ? arg.slice(2) : arg));
|
||
|
||
// Remove duplicates to avoid treating "x64 --x64" as multiple architectures
|
||
const archArgs = [...new Set(rawArchArgs)];
|
||
|
||
if (archArgs.length > 1) {
|
||
// Multiple unique architectures specified - let electron-builder handle it
|
||
multiArch = true;
|
||
targetArch = archArgs[0]; // Use first arch for webpack build
|
||
console.log(`🔨 Multi-architecture build detected: ${archArgs.join(', ')}`);
|
||
} else if (args[0] === 'auto') {
|
||
if (archArgs.length === 1) {
|
||
targetArch = archArgs[0];
|
||
} else {
|
||
// Auto mode: detect from electron-builder.yml
|
||
let detectedPlatform = null;
|
||
if (builderArgs.includes('--linux')) detectedPlatform = 'linux';
|
||
else if (builderArgs.includes('--mac')) detectedPlatform = 'mac';
|
||
else if (builderArgs.includes('--win')) detectedPlatform = 'win';
|
||
|
||
const configArch = detectedPlatform ? getTargetArchFromConfig(detectedPlatform) : null;
|
||
targetArch = configArch || buildMachineArch;
|
||
}
|
||
} else {
|
||
// Explicit architecture or default to build machine
|
||
targetArch = archArgs[0] || buildMachineArch;
|
||
}
|
||
|
||
console.log(`🔨 Building for architecture: ${targetArch}`);
|
||
console.log(`📋 Builder arguments: ${builderArgs || '(none)'}`);
|
||
if (skipVite) console.log('⚡ --skip-vite: Will skip Vite compilation if output exists');
|
||
if (skipNative) console.log('⚡ --skip-native: Will skip native module rebuilding');
|
||
if (packOnly) console.log('⚡ --pack-only: Will skip electron-builder distributable creation');
|
||
if (forceBuild) console.log('⚡ --force: Force full rebuild');
|
||
|
||
const packageJsonPath = path.resolve(__dirname, '../package.json');
|
||
let restorePackageVersionOverride = () => {};
|
||
let buildFailed = false;
|
||
|
||
try {
|
||
restorePackageVersionOverride = applyDebugAutoUpdateVersionOverride(packageJsonPath);
|
||
|
||
// 1. Ensure package.json main entry is correct for electron-vite
|
||
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
|
||
if (packageJson.main !== './out/main/index.js') {
|
||
packageJson.main = './out/main/index.js';
|
||
fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
|
||
}
|
||
|
||
// 2. Check if we can skip Vite build (incremental build)
|
||
const skipViteBuild = shouldSkipViteBuild(skipVite, forceBuild);
|
||
|
||
if (!skipViteBuild) {
|
||
// Run electron-vite to build all bundles (main + preload + renderer)
|
||
console.log(`📦 Building ${targetArch}...`);
|
||
execSync(`bunx electron-vite build --config packages/desktop/electron.vite.config.ts`, {
|
||
stdio: 'inherit',
|
||
shell: process.platform === 'win32',
|
||
env: {
|
||
...process.env,
|
||
ELECTRON_BUILDER_ARCH: targetArch,
|
||
},
|
||
});
|
||
|
||
// Save hash after successful build
|
||
saveCurrentHash(computeSourceHash());
|
||
} else {
|
||
console.log('📦 Using cached Vite build output');
|
||
}
|
||
|
||
// Re-bundle builtin MCP server as a fully self-contained CJS bundle so it can
|
||
// be executed by an external `node` process (no Electron ASAR support available).
|
||
// electron-vite's externalizeDepsPlugin leaves npm packages as require() calls
|
||
// which the standalone node process cannot resolve from inside app.asar.unpacked.
|
||
// Uses a dedicated script (build-mcp-servers.js) to avoid shell-quoting issues
|
||
// with special characters in esbuild --define values.
|
||
console.log('📦 Bundling builtin MCP servers (self-contained)...');
|
||
execSync(`node "${path.join(__dirname, 'build-mcp-servers.js')}"`, {
|
||
stdio: 'inherit',
|
||
shell: process.platform === 'win32',
|
||
});
|
||
|
||
// 3. Verify electron-vite output
|
||
const outDir = path.resolve(__dirname, '../out');
|
||
if (!fs.existsSync(outDir)) {
|
||
throw new Error('electron-vite did not generate out/ directory');
|
||
}
|
||
|
||
// 4. Validate output structure. This must reject source-only renderer shells;
|
||
// otherwise local fast builds can package a white-screen app.
|
||
const viteOutputValidation = validateViteBuildOutput();
|
||
if (!viteOutputValidation.valid) {
|
||
throw new Error(`Vite build output is incomplete:\n${viteOutputValidation.problems.join('\n')}`);
|
||
}
|
||
|
||
// If --pack-only, skip electron-builder distributable creation
|
||
if (packOnly) {
|
||
console.log('✅ Package completed! (skipped distributable creation)');
|
||
return;
|
||
}
|
||
|
||
// 5. Prepare aioncore binary (for packaged runtime usage)
|
||
const { prepareAioncore } = require('../packages/shared-scripts/src/prepare-aioncore.js');
|
||
const { resolveAioncoreVersion } = require('./resolveAioncoreVersion.js');
|
||
const projectRoot = path.resolve(__dirname, '..');
|
||
writeGeneratedSentryDsnInclude(projectRoot);
|
||
prepareAioncore({
|
||
projectRoot,
|
||
platform: process.platform,
|
||
arch: targetArch,
|
||
version: resolveAioncoreVersion(projectRoot),
|
||
});
|
||
|
||
// 6. Prepare hub resources (index.json + extension zips for offline fallback)
|
||
execSync('node scripts/prepareHubResources.js', { stdio: 'inherit', env: process.env });
|
||
|
||
// 6. 运行 electron-builder 生成分发包（DMG/ZIP/EXE等）
|
||
// Run electron-builder to create distributables (DMG/ZIP/EXE, etc.)
|
||
// Always disable auto-publish to avoid electron-builder's implicit tag-based publishing
|
||
// Publishing is handled by a separate release job in CI
|
||
const publishArg = '--publish=never';
|
||
|
||
// Set compression level based on environment
|
||
// 7za -mx accepts numeric values: 0 (store) to 9 (ultra)
|
||
// CI builds use 9 (maximum) for smallest size
|
||
// Local builds use 7 (normal) for 30-50% faster ASAR packing
|
||
const isCI = process.env.CI === 'true';
|
||
if (!process.env.ELECTRON_BUILDER_COMPRESSION_LEVEL) {
|
||
process.env.ELECTRON_BUILDER_COMPRESSION_LEVEL = isCI ? '9' : '7';
|
||
}
|
||
console.log(
|
||
`📦 Compression level: ${process.env.ELECTRON_BUILDER_COMPRESSION_LEVEL} (${isCI ? 'CI build' : 'local build'})`
|
||
);
|
||
|
||
// 根据模式添加架构标志
|
||
// Add arch flags based on mode
|
||
let archFlag = '';
|
||
if (multiArch) {
|
||
// 多架构模式：将所有架构标志传递给 electron-builder
|
||
// Multi-arch mode: pass all arch flags to electron-builder
|
||
archFlag = archArgs.map((arch) => `--${arch}`).join(' ');
|
||
console.log(`🚀 Packaging for multiple architectures: ${archArgs.join(', ')}...`);
|
||
} else {
|
||
// 单架构模式：使用确定的目标架构
|
||
// Single arch mode: use the determined target arch
|
||
archFlag = `--${targetArch}`;
|
||
console.log(`🚀 Creating distributables for ${targetArch}...`);
|
||
}
|
||
|
||
// 为 Windows 构建添加架构检测脚本
|
||
// Add architecture detection scripts for Windows builds
|
||
// 使用 .onVerifyInstDir 避免与 electron-builder 冲突
|
||
// Use .onVerifyInstDir to avoid conflicts with electron-builder
|
||
let nsisInclude = '';
|
||
if (builderArgs.includes('--win') || builderArgs.includes('--all')) {
|
||
if (!multiArch) {
|
||
// 单架构构建：添加对应架构的检测脚本
|
||
// Single-arch build: Add architecture-specific detection script
|
||
if (targetArch === 'arm64') {
|
||
const arm64Script = 'resources/windows/windows-installer-arm64.nsh';
|
||
if (fs.existsSync(path.resolve(__dirname, '..', arm64Script))) {
|
||
nsisInclude += ` --config.nsis.include="${arm64Script}"`;
|
||
console.log(`📋 Including Windows ARM64 architecture check script`);
|
||
}
|
||
nsisInclude += ' --config.nsis.useZip=true';
|
||
console.log('📋 Using ZIP payload for Windows ARM64 NSIS installer');
|
||
} else if (targetArch === 'x64') {
|
||
const x64Script = 'resources/windows/windows-installer-x64.nsh';
|
||
if (fs.existsSync(path.resolve(__dirname, '..', x64Script))) {
|
||
nsisInclude += ` --config.nsis.include="${x64Script}"`;
|
||
console.log(`📋 Including Windows x64 architecture check script`);
|
||
}
|
||
}
|
||
}
|
||
// 多架构构建：暂不支持架构检测脚本
|
||
// Multi-arch builds: Architecture detection not supported yet
|
||
}
|
||
|
||
if (process.platform === 'win32' && builderArgs.includes('--win')) {
|
||
const winUnpackedDir = path.join(outDir, 'win-unpacked');
|
||
let cleaned = tryRemoveDir(winUnpackedDir);
|
||
if (!cleaned) {
|
||
const aionRunning = isProcessRunningWindows('AionUi.exe');
|
||
const electronRunning = isProcessRunningWindows('electron.exe');
|
||
if (aionRunning || electronRunning) {
|
||
console.log('⚠️ Detected running AionUi/Electron process. Attempting to close...');
|
||
killWindowsProcesses(['AionUi.exe', 'electron.exe']);
|
||
cleaned = tryRemoveDir(winUnpackedDir);
|
||
if (!cleaned) {
|
||
console.log('⚠️ Directory still locked. Please close any running AionUi/Electron processes and retry.');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
const isWindowsBuild = builderArgs.includes('--win') || builderArgs.includes('--all');
|
||
if (isWindowsBuild) {
|
||
patchElectronBuilderNsisInstaller();
|
||
cleanupWindowsPackOutput();
|
||
}
|
||
|
||
const builderCommand = `bunx electron-builder --config packages/desktop/electron-builder.yml ${builderArgs} ${archFlag} ${nsisInclude} ${publishArg}`;
|
||
try {
|
||
buildWithDmgRetry(builderCommand, targetArch);
|
||
} catch (error) {
|
||
const winExePath = path.join(outDir, 'win-unpacked', 'AionUi.exe');
|
||
const firstError = formatExecError(error);
|
||
const canRetryWithoutExecutableEdit =
|
||
process.platform === 'win32' && isWindowsBuild && process.env.CI !== 'true' && fs.existsSync(winExePath);
|
||
|
||
if (!canRetryWithoutExecutableEdit) {
|
||
throw error;
|
||
}
|
||
|
||
console.log('⚠️ Windows local build failed after AionUi.exe was produced.');
|
||
if (firstError) {
|
||
console.log(' First failure summary:');
|
||
console.log(
|
||
firstError
|
||
.split(/\r?\n/)
|
||
.slice(0, 6)
|
||
.map((line) => ` ${line}`)
|
||
.join('\n')
|
||
);
|
||
}
|
||
console.log(' Retrying local build with win.signAndEditExecutable=false...');
|
||
console.log(' This fallback is intended for transient rcedit / file-lock failures on developer machines.');
|
||
killWindowsProcesses(['AionUi.exe', 'electron.exe']);
|
||
cleanupWindowsPackOutput();
|
||
|
||
try {
|
||
buildWithDmgRetry(`${builderCommand} --config.win.signAndEditExecutable=false`, targetArch);
|
||
} catch (retryError) {
|
||
const retryFailure = formatExecError(retryError);
|
||
throw new Error(
|
||
[
|
||
'Windows local retry with win.signAndEditExecutable=false also failed.',
|
||
'First failure:',
|
||
firstError || String(error),
|
||
'Retry failure:',
|
||
retryFailure || String(retryError),
|
||
].join('\n')
|
||
);
|
||
}
|
||
}
|
||
|
||
console.log('✅ Build completed!');
|
||
} catch (error) {
|
||
buildFailed = true;
|
||
console.error('❌ Build failed:', error.message);
|
||
process.exitCode = 1;
|
||
} finally {
|
||
try {
|
||
restorePackageVersionOverride();
|
||
} catch (restoreError) {
|
||
console.error('❌ Failed to restore package.json version:', restoreError.message);
|
||
if (!buildFailed) {
|
||
process.exitCode = 1;
|
||
}
|
||
}
|
||
}
|