Fix Windows auto-update manifest publishing

Author: beNative

electron/main.ts

@@ -46,6 +46,15 @@ log.catchErrors({
 
 console.log(`Log file will be written to: ${log.transports.file.getFile().path}`);
 
+if (process.platform === 'win32') {
+  const arch = process.arch === 'ia32' ? 'ia32' : process.arch === 'arm64' ? 'arm64' : 'x64';
+  const channel = `win32-${arch}`;
+  if (autoUpdater.channel !== channel) {
+    console.log(`Configuring auto-updater channel for Windows architecture: ${channel}`);
+    autoUpdater.channel = channel;
+  }
+}
+
 let mainWindow: BrowserWindow | null;
 let autoCheckEnabled = true;
 let pendingAutoUpdateCheck: NodeJS.Timeout | null = null;

scripts/__tests__/release-workflow.test.mjs

@@ -201,9 +201,17 @@ test('release tooling rewrites metadata and keeps latest.yml published', async (
   const entries = readManifestEntries(manifest);
   const relativeInstaller = path.relative(repoPath(), renamedInstaller);
   const relativeLatest = path.relative(repoPath(), latestPath);
+  const relativeWinChannel = path.relative(
+    repoPath(),
+    path.join(releaseDir, 'win32-x64.yml'),
+  );
 
   assert(entries.includes(relativeInstaller), 'Installer should be present in manifest after renaming');
   assert(entries.includes(relativeLatest), 'latest.yml must be uploaded as part of the release');
+  assert(
+    entries.includes(relativeWinChannel),
+    'win32-x64.yml must be uploaded for architecture-specific Windows updates',
+  );
 
   const installerBuffer = await fs.readFile(renamedInstaller);
   const expectedSha = computeSha512Base64(installerBuffer);
@@ -352,15 +360,37 @@ test('release workflow verifies metadata directories across platforms and publis
   });
 
   const manifestEntries = new Set(readManifestEntries(await fs.readFile(manifestPath, 'utf8')));
-  const metadataFiles = [ia32.metadataPath, x64.metadataPath, linux.metadataPath, mac.metadataPath];
-  for (const metadataPath of metadataFiles) {
-    assert(metadataPath, 'metadataPath should be defined for all fixtures');
+  const expectedMetadataUploads = [x64.metadataPath, linux.metadataPath, mac.metadataPath];
+  for (const metadataPath of expectedMetadataUploads) {
+    assert(metadataPath, 'metadataPath should be defined for uploaded manifests');
     const relativePath = path.relative(repoPath(), metadataPath);
     assert(manifestEntries.has(relativePath), `${relativePath} must be included in release manifest`);
   }
 
+  const ia32LatestRelative = path.relative(repoPath(), ia32.metadataPath);
+  assert(
+    !manifestEntries.has(ia32LatestRelative),
+    'Windows ia32 latest.yml should be replaced by architecture-specific manifest to avoid duplicate assets',
+  );
+
+  const windowsChannels = [
+    path.relative(repoPath(), path.join(ia32.releaseDir, 'win32-ia32.yml')),
+    path.relative(repoPath(), path.join(x64.releaseDir, 'win32-x64.yml')),
+  ];
+  for (const channel of windowsChannels) {
+    assert(manifestEntries.has(channel), `${channel} must be uploaded for Windows auto-update`);
+  }
+
   const metadataDirs = await listMetadataDirectories(path.join(workspace, 'release-artifacts'));
-  assert(metadataDirs.length >= metadataFiles.length, 'expected to discover metadata directories');
+  const expectedDirs = [ia32.metadataPath, x64.metadataPath, linux.metadataPath, mac.metadataPath]
+    .filter(Boolean)
+    .map((metadataPath) => path.dirname(metadataPath));
+  for (const expectedDir of expectedDirs) {
+    assert(
+      metadataDirs.includes(expectedDir),
+      `${expectedDir} should be discovered for metadata verification`,
+    );
+  }
 
   for (const dir of metadataDirs) {
     await runLocalVerification(dir);
@@ -423,8 +453,8 @@ test('remote auto-update check fails when Windows release metadata is absent', a
       assert(error instanceof Error, 'Expected runRemoteCheck to reject with an Error instance');
       assert.match(
         error.message,
-        /Missing required auto-update metadata asset[\s\S]*latest\.yml/,
-        'Error message should mention latest.yml as the missing manifest',
+        /Missing required auto-update metadata asset[\s\S]*latest\.yml[\s\S]*win32-<arch>\.yml/,
+        'Error message should mention both legacy and architecture-specific manifests',
       );
       return true;
     },

scripts/generate-release-notes.mjs

@@ -252,7 +252,12 @@ async function collectAssets(artifactRoot) {
       const filePath = normalisedPath;
       const artifactDir = path.relative(artifactRoot, path.dirname(filePath));
       if (isAutoUpdateSupportFile(fileName)) {
-        updateSupportFiles.push({ filePath, artifactDir });
+        updateSupportFiles.push({
+          filePath,
+          artifactDir,
+          assetName: path.basename(filePath),
+          upload: true,
+        });
         continue;
       }
 
@@ -275,6 +280,7 @@ async function collectAssets(artifactRoot) {
         format: detectFormat(fileName),
         sha512,
         size,
+        assetName: fileName,
       });
     }
   }
@@ -296,6 +302,74 @@ async function collectAssets(artifactRoot) {
   return { releaseAssets, updateSupportFiles };
 }
 
+function normaliseWindowsChannelName(arch) {
+  if (!arch) {
+    return null;
+  }
+  const normalised = arch.toLowerCase();
+  if (['x64', 'ia32', 'arm64'].includes(normalised)) {
+    return `win32-${normalised}`;
+  }
+  return `win32-${normalised.replace(/[^a-z0-9]+/gi, '-')}`;
+}
+
+async function prepareMetadataUploads({ releaseAssets, updateSupportFiles }) {
+  if (updateSupportFiles.length === 0) {
+    return;
+  }
+
+  const releaseAssetsByDir = new Map();
+  for (const asset of releaseAssets) {
+    if (!releaseAssetsByDir.has(asset.artifactDir)) {
+      releaseAssetsByDir.set(asset.artifactDir, { assets: [], arch: asset.arch });
+    }
+    const entry = releaseAssetsByDir.get(asset.artifactDir);
+    entry.assets.push(asset);
+    if (!entry.arch && asset.arch) {
+      entry.arch = asset.arch;
+    }
+  }
+
+  const windowsMetadata = updateSupportFiles.filter((file) => {
+    const name = path.basename(file.filePath).toLowerCase();
+    return name === 'latest.yml' && file.artifactDir.startsWith('docforge-windows-');
+  });
+
+  if (windowsMetadata.length === 0) {
+    return;
+  }
+
+  const canonical =
+    windowsMetadata.find((file) => {
+      const info = releaseAssetsByDir.get(file.artifactDir);
+      return info?.arch === 'x64';
+    }) ?? windowsMetadata[0];
+
+  for (const file of windowsMetadata) {
+    const info = releaseAssetsByDir.get(file.artifactDir);
+    const channelName = normaliseWindowsChannelName(info?.arch ?? 'windows');
+    if (!channelName) {
+      continue;
+    }
+    const aliasName = `${channelName}.yml`;
+    const aliasPath = path.join(path.dirname(file.filePath), aliasName);
+    await fs.copyFile(file.filePath, aliasPath);
+    updateSupportFiles.push({
+      filePath: aliasPath,
+      artifactDir: file.artifactDir,
+      assetName: aliasName,
+      upload: true,
+    });
+
+    file.assetName = path.basename(file.filePath);
+    if (file === canonical) {
+      file.upload = true;
+    } else {
+      file.upload = false;
+    }
+  }
+}
+
 async function updateMetadataFiles(metadataFiles, releaseAssets) {
   if (metadataFiles.length === 0) {
     return;
@@ -550,9 +624,26 @@ async function main() {
   const releaseNotes = sections.join('\n').replace(/\n{3,}/g, '\n\n');
   await fs.writeFile(outputPath, `${releaseNotes}\n`, 'utf8');
 
+  await prepareMetadataUploads({ releaseAssets, updateSupportFiles });
+  updateSupportFiles.sort((a, b) => a.filePath.localeCompare(b.filePath));
+
   const manifestEntries = [
-    ...releaseAssets.map((asset) => path.relative(process.cwd(), asset.filePath)),
-    ...updateSupportFiles.map((file) => path.relative(process.cwd(), file.filePath)),
+    ...releaseAssets.map((asset) => {
+      const relative = path.relative(process.cwd(), asset.filePath);
+      if (asset.assetName && path.basename(asset.filePath) !== asset.assetName) {
+        return `${relative}#${asset.assetName}`;
+      }
+      return relative;
+    }),
+    ...updateSupportFiles
+      .filter((file) => file.upload !== false)
+      .map((file) => {
+        const relative = path.relative(process.cwd(), file.filePath);
+        if (file.assetName && path.basename(file.filePath) !== file.assetName) {
+          return `${relative}#${file.assetName}`;
+        }
+        return relative;
+      }),
   ];
   const manifest = manifestEntries.join('\n');
   await fs.writeFile(filesOutputPath, `${manifest}\n`, 'utf8');

scripts/test-auto-update.mjs

@@ -363,14 +363,33 @@ export async function analyseMetadataEntry({
 function describeMissingMetadataAssets(assetEntries, metadataAssets) {
   const missing = [];
   const windowsInstallers = assetEntries.filter((asset) => asset.name.endsWith('.exe'));
+
+  if (windowsInstallers.length === 0) {
+    return missing;
+  }
+
+  const installerList = windowsInstallers.map((asset) => asset.name).join(', ');
   const hasLatest = metadataAssets.some((asset) => asset.name === 'latest.yml');
+  const hasWindowsChannel = metadataAssets.some(
+    (asset) => asset.name.startsWith('win32-') && asset.name.endsWith('.yml'),
+  );
+
+  if (!hasLatest) {
+    missing.push(
+      [
+        'latest.yml (required for legacy Windows auto-update clients)',
+        installerList ? `Windows installers detected: ${installerList}` : null,
+      ]
+        .filter(Boolean)
+        .join(' - '),
+    );
+  }
 
-  if (windowsInstallers.length > 0 && !hasLatest) {
-    const installers = windowsInstallers.map((asset) => asset.name).join(', ');
+  if (!hasWindowsChannel) {
     missing.push(
       [
-        'latest.yml (required for Windows auto-update)',
-        installers ? `Windows installers detected: ${installers}` : null,
+        'win32-<arch>.yml (required for architecture-specific Windows auto-update channels)',
+        installerList ? `Windows installers detected: ${installerList}` : null,
       ]
         .filter(Boolean)
         .join(' - '),