resedit.ts

import * as fs from 'fs-extra';
// eslint-disable-next-line import/no-unresolved
import { load as loadResEdit } from 'resedit/cjs';
import { Win32MetadataOptions } from './types';
import { FileRecord } from '@electron/asar';

export type ExeMetadata = {
  productVersion?: string;
  fileVersion?: string;
  legalCopyright?: string;
  productName?: string;
  iconPath?: string;
  asarIntegrity?: Record<string, Pick<FileRecord['integrity'], 'algorithm' | 'hash'>>;
  win32Metadata?: Win32MetadataOptions;
}

type ParsedVersionNumerics = [number, number, number, number];

/**
 * Parse a version string in the format a.b.c.d with each component being optional
 * but if present must be an integer. Matches the impl in rcedit for compat
 */
function parseVersionString(str: string): ParsedVersionNumerics {
  const parts = str.split('.');
  if (parts.length === 0 || parts.length > 4) {
    throw new Error(`Incorrectly formatted version string: "${str}". Should have at least one and at most four components`);
  }
  return parts.map((part) => {
    const parsed = parseInt(part, 10);
    if (isNaN(parsed)) {
      throw new Error(`Incorrectly formatted version string: "${str}". Component "${part}" could not be parsed as an integer`);
    }
    return parsed;
  }) as ParsedVersionNumerics;
}

// Ref: https://learn.microsoft.com/en-us/windows/win32/menurc/resource-types
const RT_MANIFEST_TYPE = 24;

export async function resedit(exePath: string, options: ExeMetadata) {
  const resedit = await loadResEdit();

  const exeData = await fs.readFile(exePath);
  const exe = resedit.NtExecutable.from(exeData);
  const res = resedit.NtExecutableResource.from(exe);

  if (options.iconPath) {
    // Icon Info
    const existingIconGroups = resedit.Resource.IconGroupEntry.fromEntries(res.entries);
    if (existingIconGroups.length !== 1) {
      throw new Error('Failed to parse win32 executable resources, failed to locate existing icon group');
    }
    const iconFile = resedit.Data.IconFile.from(await fs.readFile(options.iconPath));
    resedit.Resource.IconGroupEntry.replaceIconsForResource(
      res.entries,
      existingIconGroups[0].id,
      existingIconGroups[0].lang,
      iconFile.icons.map((item) => item.data)
    );
  }

  // Manifest
  if (options.win32Metadata?.['application-manifest'] || options.win32Metadata?.['requested-execution-level']) {
    if (options.win32Metadata?.['application-manifest'] && options.win32Metadata?.['requested-execution-level']) {
      throw new Error('application-manifest and requested-execution-level are mutually exclusive, only provide one');
    }

    const manifests = res.entries.filter(e => e.type === RT_MANIFEST_TYPE);
    if (manifests.length !== 1) {
      throw new Error('Failed to parse win32 executable resources, failed to locate existing manifest');
    }
    const manifestEntry = manifests[0];
    if (options.win32Metadata?.['application-manifest']) {
      manifestEntry.bin = (await fs.readFile(options.win32Metadata?.['application-manifest'])).buffer;
    } else if (options.win32Metadata?.['requested-execution-level']) {
      // This implementation matches what rcedit used to do, in theory we can be Smarter
      // and use an actual XML parser, but for now let's match the old impl
      const currentManifestContent = Buffer.from(manifestEntry.bin).toString('utf-8');
      const newContent = currentManifestContent.replace(
        /(<requestedExecutionLevel level=")asInvoker(" uiAccess="false"\/>)/g,
        `$1${options.win32Metadata?.['requested-execution-level']}$2`
      );
      manifestEntry.bin = Buffer.from(newContent, 'utf-8');
    }
  }

  // Version Info
  const versionInfo = resedit.Resource.VersionInfo.fromEntries(res.entries);
  if (versionInfo.length !== 1) {
    throw new Error('Failed to parse win32 executable resources, failed to locate existing version info');
  }
  if (options.fileVersion) versionInfo[0].setFileVersion(...parseVersionString(options.fileVersion));
  if (options.productVersion) versionInfo[0].setProductVersion(...parseVersionString(options.productVersion));
  const languageInfo = versionInfo[0].getAllLanguagesForStringValues();
  if (languageInfo.length !== 1) {
    throw new Error('Failed to parse win32 executable resources, failed to locate existing language info');
  }
  // Empty strings retain original value
  const newStrings: Record<string, string> = {
    CompanyName: options.win32Metadata?.CompanyName || '',
    FileDescription: options.win32Metadata?.FileDescription || '',
    FileVersion: options.fileVersion || '',
    InternalName: options.win32Metadata?.InternalName || '',
    LegalCopyright: options.legalCopyright || '',
    OriginalFilename: options.win32Metadata?.OriginalFilename || '',
    ProductName: options.productName || '',
    ProductVersion: options.productVersion || '',
  };
  for (const key of Object.keys(newStrings)) {
    if (!newStrings[key]) delete newStrings[key];
  }
  versionInfo[0].setStringValues(languageInfo[0], newStrings);

  // Output version info
  versionInfo[0].outputToResourceEntries(res.entries);

  // Asar Integrity
  if (options.asarIntegrity) {
    const integrityList = Object.keys(options.asarIntegrity).map((file) => ({
      file,
      alg: options.asarIntegrity![file].algorithm,
      value: options.asarIntegrity![file].hash,
    }));
    res.entries.push({
      type: 'INTEGRITY',
      id: 'ELECTRONASAR',
      bin: Buffer.from(JSON.stringify(integrityList), 'utf-8'),
      lang: languageInfo[0].lang,
      codepage: languageInfo[0].codepage,
    });
  }

  res.outputResource(exe);

  await fs.writeFile(exePath, Buffer.from(exe.generate()));
}