feat: write appVersion into the packaged app's package.json

The resolved appVersion is now written to the version field of the
copied app's package.json (in the staging directory, never the user's
source directory) before asar packing. This makes app.getVersion()
return the correct version on platforms without executable version
metadata (i.e. Linux), consistent with the existing metadata stamping
on Windows and macOS.

Closes #1331

Author: claude

src/platform.ts

@@ -177,9 +177,36 @@ export class App {
   async buildApp() {
     await this.copyTemplate();
     await validateElectronApp(this.opts.dir, this.originalResourcesAppDir);
+    await this.writeAppVersion();
     await this.asarApp();
   }
 
+  /**
+   * Writes the resolved {@link Options.appVersion | appVersion} to the `version` field of the
+   * copied app's `package.json`, so that `app.getVersion()` returns it at runtime even on
+   * platforms that don't store the version in executable metadata (i.e. Linux).
+   *
+   * Only the copy of the app in the staging directory is modified, never the user's source
+   * directory.
+   */
+  async writeAppVersion() {
+    if (typeof this.opts.appVersion !== 'string') {
+      return;
+    }
+
+    const packageJSONPath = path.join(this.originalResourcesAppDir, 'package.json');
+    const packageJSON = JSON.parse(
+      (await fs.promises.readFile(packageJSONPath, 'utf8')).replace(/^\uFEFF/, ''),
+    );
+    if (packageJSON.version === this.opts.appVersion) {
+      return;
+    }
+
+    debug(`Setting version in ${packageJSONPath} to ${this.opts.appVersion}`);
+    packageJSON.version = this.opts.appVersion;
+    await fs.promises.writeFile(packageJSONPath, JSON.stringify(packageJSON, null, 2));
+  }
+
   async copyTemplate() {
     await runHooks(this.opts.beforeCopy, this.hookArgsWithOriginalResourcesAppDir);
 

src/types.ts

@@ -255,6 +255,10 @@ export interface Options {
    * with this argument. If neither are provided, the version of Electron will be used. Maps
    * to the `ProductVersion` metadata property on Windows, and `CFBundleShortVersionString`
    * on macOS.
+   *
+   * The resolved value is also written to the `version` field of the packaged app's
+   * `package.json`, which is how the version reaches `app.getVersion()` at runtime on
+   * platforms without executable version metadata, such as Linux.
    */
   appVersion?: string;
   /**

test/packager.spec.ts

@@ -15,6 +15,7 @@ import {
   parseInfoPlist,
 } from './utils.js';
 import { OfficialArch, OfficialPlatform, Options } from '../src/types.js';
+import { extractFile } from '@electron/asar';
 import { createDownloadOpts, downloadElectronZip } from '../src/download.js';
 import plist, { PlistObject } from 'plist';
 import { filterCFBundleIdentifier } from '../src/mac.js';
@@ -477,6 +478,58 @@ describe('packager', () => {
     });
   });
 
+  describe('appVersion', () => {
+    it('writes appVersion into the packaged package.json', async ({ baseOpts }) => {
+      const opts = {
+        ...baseOpts,
+        appVersion: '1.2.3',
+        platform: 'linux',
+        arch: 'x64',
+      } as const;
+
+      const paths = await packager(opts);
+      expect(paths).toHaveLength(1);
+
+      const asarPath = path.join(
+        paths[0],
+        generateResourcesPath({ name: opts.name, platform: opts.platform }),
+        'app.asar',
+      );
+      const packageJSON = JSON.parse(extractFile(asarPath, 'package.json').toString('utf8'));
+      expect(packageJSON.version).toEqual('1.2.3');
+
+      // The user's source package.json must never be modified
+      const sourcePackageJSON = JSON.parse(
+        fs.readFileSync(path.join(opts.dir, 'package.json'), 'utf8'),
+      );
+      expect(sourcePackageJSON.version).toEqual('4.99.101');
+    });
+
+    it('writes appVersion into the packaged package.json when asar is disabled', async ({
+      baseOpts,
+    }) => {
+      const opts = {
+        ...baseOpts,
+        appVersion: '5.6.7',
+        asar: false,
+        platform: 'linux',
+        arch: 'x64',
+      } as const;
+
+      const paths = await packager(opts);
+      expect(paths).toHaveLength(1);
+
+      const packageJSONPath = path.join(
+        paths[0],
+        generateResourcesPath({ name: opts.name, platform: opts.platform }),
+        'app',
+        'package.json',
+      );
+      const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath, 'utf8'));
+      expect(packageJSON.version).toEqual('5.6.7');
+    });
+  });
+
   it('should ignore previously-packaged out dir', async ({ baseOpts }) => {
     const fixture = path.join(__dirname, 'fixtures', 'basic');
     const opts = {

test/platform.spec.ts

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { App } from '../src/platform.js';
+import type { ProcessedOptionsWithSinglePlatformArch } from '../src/types.js';
+
+describe('App.writeAppVersion', () => {
+  let out: string;
+
+  afterEach(async () => {
+    await fs.promises.rm(out, { recursive: true, force: true });
+  });
+
+  async function createApp(appVersion: string | undefined, packageJSON: Record<string, unknown>) {
+    out = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'electron-packager-platform-test-'));
+    const opts = {
+      name: 'writeAppVersionTest',
+      dir: path.join(__dirname, 'fixtures', 'basic'),
+      out,
+      tmpdir: false,
+      platform: 'linux',
+      arch: 'x64',
+      electronVersion: '27.0.0',
+      appVersion,
+      ignore: [],
+    } as unknown as ProcessedOptionsWithSinglePlatformArch;
+
+    const app = new App(opts, path.join(out, 'template'));
+    await fs.promises.mkdir(app.originalResourcesAppDir, { recursive: true });
+    const packageJSONPath = path.join(app.originalResourcesAppDir, 'package.json');
+    await fs.promises.writeFile(packageJSONPath, JSON.stringify(packageJSON, null, 2));
+
+    return { app, packageJSONPath };
+  }
+
+  it('writes the resolved appVersion to the copied package.json', async () => {
+    const { app, packageJSONPath } = await createApp('1.2.3', {
+      name: 'test-app',
+      main: 'main.js',
+      version: '0.0.1',
+    });
+
+    await app.writeAppVersion();
+
+    const packageJSON = JSON.parse(await fs.promises.readFile(packageJSONPath, 'utf8'));
+    expect(packageJSON.version).toEqual('1.2.3');
+    expect(packageJSON.name).toEqual('test-app');
+    expect(packageJSON.main).toEqual('main.js');
+  });
+
+  it('adds a version field if the copied package.json does not have one', async () => {
+    const { app, packageJSONPath } = await createApp('4.5.6', {
+      name: 'test-app',
+      main: 'main.js',
+    });
+
+    await app.writeAppVersion();
+
+    const packageJSON = JSON.parse(await fs.promises.readFile(packageJSONPath, 'utf8'));
+    expect(packageJSON.version).toEqual('4.5.6');
+  });
+
+  it('does not modify the package.json if appVersion is not resolved', async () => {
+    const { app, packageJSONPath } = await createApp(undefined, {
+      name: 'test-app',
+      main: 'main.js',
+    });
+    const originalContents = await fs.promises.readFile(packageJSONPath, 'utf8');
+
+    await app.writeAppVersion();
+
+    expect(await fs.promises.readFile(packageJSONPath, 'utf8')).toEqual(originalContents);
+    expect(JSON.parse(originalContents).version).toBeUndefined();
+  });
+
+  it('does not rewrite the package.json if the version already matches', async () => {
+    const { app, packageJSONPath } = await createApp('1.2.3', {
+      name: 'test-app',
+      main: 'main.js',
+      version: '1.2.3',
+    });
+    // Formatting that a rewrite would not preserve
+    await fs.promises.writeFile(
+      packageJSONPath,
+      '{"name":"test-app","main":"main.js","version":"1.2.3"}',
+    );
+
+    await app.writeAppVersion();
+
+    expect(await fs.promises.readFile(packageJSONPath, 'utf8')).toEqual(
+      '{"name":"test-app","main":"main.js","version":"1.2.3"}',
+    );
+  });
+});