@omega.js/desktop 0.50.0 → 0.51.0

package/dist/test/suites/build/deploy-hook.test.js

@@ -0,0 +1,169 @@
+// Build-layer test for the deploy verb's consumer hook
+// ([#899](https://github.com/Omega-JS-Stack/omega/issues/899)).
+//
+// `omega deploy` runs the consumer's `hooks/deploy/pre.js` after the local
+// scaffold and BEFORE the network precheck, on both lanes, through the same
+// runner the build and release hooks use. A dry run skips it: a hook may act on
+// the world (the playground's prunes its GitHub releases), and a dry run
+// promises to send nothing.
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const Module = require('module');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+const attachLogFile = require('../../../vendor/devkit/attach-log-file.js');
+
+const COMMANDS = path.join(__dirname, '..', '..', '..', 'commands');
+const DEPLOY = path.join(COMMANDS, 'deploy.js');
+
+/**
+ * Swap ONE module for a recorder and hand back the undo (the deploy-direct
+ * test's seam: the scaffold and the precheck are the two steps around the
+ * hook, and everything else in the verb is the real code).
+ *
+ * @param {string} file - The module to replace.
+ * @param {object} exports - What it exports for the duration.
+ * @returns {Function} The restore.
+ */
+function stubModule(file, exports) {
+  const resolved = require.resolve(file);
+  const previous = require.cache[resolved];
+  const stub = new Module(resolved);
+
+  stub.filename = resolved;
+  stub.loaded = true;
+  stub.exports = exports;
+  require.cache[resolved] = stub;
+
+  return () => {
+    if (previous) require.cache[resolved] = previous;
+    else delete require.cache[resolved];
+  };
+}
+
+/**
+ * Run the deploy verb against a consumer dir whose `hooks/deploy/pre.js`
+ * records its call, with the precheck stubbed to stop the run right there.
+ *
+ * @param {object} options - The verb's options.
+ * @returns {Promise<string[]>} The steps that ran, in order.
+ */
+async function runDeploy(options) {
+  const ran = [];
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-deploy-hook-'));
+
+  fs.mkdirSync(path.join(tmp, 'hooks', 'deploy'), { recursive: true });
+  fs.writeFileSync(path.join(tmp, 'package.json'), '{"name":"desktop-deploy-hook-test"}');
+  fs.writeFileSync(
+    path.join(tmp, 'hooks', 'deploy', 'pre.js'),
+    `module.exports = async (ctx) => { global.__omegaDeployHookRan.push('deploy/pre:' + (ctx.projectRoot === process.cwd() && typeof ctx.manager === 'object' && ctx.mode === 'production' ? 'ctx ok' : 'ctx wrong')); };`,
+  );
+
+  const restores = [
+    stubModule(path.join(COMMANDS, 'lib', 'ensure-target.js'), { ensureTarget: async () => ran.push('ensure-target') }),
+    stubModule(path.join(COMMANDS, 'lib', 'deploy-precheck.js'), { deployPrecheck: async () => { ran.push('precheck'); throw new Error('STOP AT PRECHECK'); } }),
+  ];
+  const resolved = require.resolve(DEPLOY);
+  const cached = require.cache[resolved];
+  const origCwd = process.cwd();
+
+  delete require.cache[resolved];
+  global.__omegaDeployHookRan = ran;
+
+  try {
+    // Required BEFORE the chdir: the verb builds its Manager at load time from
+    // the real target; only the hook lookup reads cwd, at call time.
+    const deploy = require(resolved);
+    process.chdir(tmp);
+    await deploy(options).catch((e) => ran.push(e.message));
+    return ran;
+  } finally {
+    // The verb tees this process' writers now (#873): hand them back.
+    attachLogFile.detach();
+    process.chdir(origCwd);
+    delete global.__omegaDeployHookRan;
+    for (const restore of restores) restore();
+    if (cached) require.cache[resolved] = cached;
+    else delete require.cache[resolved];
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+/**
+ * The same seam, run inside a DRIFTED brand: the root says 0.0.3 and this
+ * target still says 0.0.2 ([#869](https://github.com/Omega-JS-Stack/omega/issues/869)).
+ *
+ * @returns {Promise<string[]>} The steps that ran, in order.
+ */
+async function runDriftedDeploy() {
+  const ran = [];
+  const brand = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-deploy-drift-')));
+  const target = path.join(brand, 'targets', 'desktop');
+
+  fs.mkdirSync(path.join(brand, 'config'), { recursive: true });
+  fs.writeFileSync(path.join(brand, 'config', 'omega.json5'), '{ brand: { id: \'fixture\' }, targets: { desktop: { type: \'desktop\' } } }');
+  fs.writeFileSync(path.join(brand, 'package.json'), '{"name":"fixture-brand","version":"0.0.3"}');
+  fs.mkdirSync(target, { recursive: true });
+  fs.writeFileSync(path.join(target, 'package.json'), '{"name":"fixture-desktop","version":"0.0.2"}');
+
+  const restores = [
+    stubModule(path.join(COMMANDS, 'lib', 'ensure-target.js'), { ensureTarget: async () => ran.push('ensure-target') }),
+    stubModule(path.join(COMMANDS, 'lib', 'deploy-precheck.js'), { deployPrecheck: async () => { ran.push('precheck'); throw new Error('STOP AT PRECHECK'); } }),
+  ];
+  const resolved = require.resolve(DEPLOY);
+  const cached = require.cache[resolved];
+  const origCwd = process.cwd();
+
+  delete require.cache[resolved];
+
+  try {
+    const deploy = require(resolved);
+    process.chdir(target);
+    await deploy({}).catch((e) => ran.push(e.message));
+    return ran;
+  } finally {
+    // The verb tees this process' writers now (#873): hand them back.
+    attachLogFile.detach();
+    process.chdir(origCwd);
+    for (const restore of restores) restore();
+    if (cached) require.cache[resolved] = cached;
+    else delete require.cache[resolved];
+    fs.rmSync(brand, { recursive: true, force: true });
+  }
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'deploy: the consumer\'s hooks/deploy/pre.js runs before the precheck (#899)',
+  tests: [
+    {
+      name: 'the hook runs after the scaffold and before the network precheck, with { manager, projectRoot, mode: production }',
+      run: async (ctx) => {
+        const ran = await runDeploy({});
+        ctx.expect(ran).toEqual(['ensure-target', 'deploy/pre:ctx ok', 'precheck', 'STOP AT PRECHECK']);
+      },
+    },
+    {
+      name: 'a dry run skips the hook: a hook may act on the world, and a dry run sends nothing',
+      run: async (ctx) => {
+        const ran = await runDeploy({ dryRun: true });
+        ctx.expect(ran).toEqual(['ensure-target', 'precheck', 'STOP AT PRECHECK']);
+      },
+    },
+    {
+      name: 'a target whose version drifted from the brand root is refused before the hook and the precheck (#869)',
+      run: async (ctx) => {
+        const ran = await runDriftedDeploy();
+
+        ctx.expect(ran.length).toBe(2);
+        ctx.expect(ran[0]).toBe('ensure-target');
+        ctx.expect(ran[1]).toContain('targets/desktop is 0.0.2 but the brand is 0.0.3');
+        ctx.expect(ran[1]).toContain('omega bump');
+        // The precheck never ran: a drifted target must not push its secrets.
+        ctx.expect(ran).not.toContain('precheck');
+      },
+    },
+  ],
+});

package/dist/test/suites/build/ensure-target.test.js

@@ -22,8 +22,8 @@ const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 const package = Manager.getPackage('main');
 
 // A consumer whose peer deps are already satisfied — the steady state.
-function stageConsumer() {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-ensure-'));
+function stageConsumer(dir) {
+  const tmp = dir || fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-ensure-'));
   const devDependencies = { [package.name]: `^${package.version}` };
   for (const [name, ver] of Object.entries(package.peerDependencies || {})) {
     devDependencies[name] = ver;
@@ -117,6 +117,18 @@ module.exports = defineCases({
         ctx.expect(result.ran).toEqual(ran);
       },
     },
+    {
+      // Both SIGNING rungs stop the deploy instead of narrating it (#891): a
+      // refused or half secret publish hands CI a set it cannot sign with.
+      name: 'deploy precheck: validate-certs and push-secrets are FATAL (#891)',
+      run: (ctx) => {
+        const { STEPS } = require(path.join(__dirname, '..', '..', '..', 'commands', 'lib', 'deploy-precheck.js'));
+
+        ctx.expect(STEPS.map((step) => step.name)).toEqual(['framework-freshness', 'validate-certs', 'provision-repos', 'push-secrets']);
+        ctx.expect(STEPS.filter((step) => step.fatal === true).map((step) => step.name))
+          .toEqual(['validate-certs', 'push-secrets']);
+      },
+    },
     {
       name: 'cli: no `setup` command, and a bare invocation resolves to help',
       run: (ctx) => {

package/dist/test/suites/build/env-delivery.test.js

@@ -1,7 +1,8 @@
 // The env schema is the ONE declaration of how a key reaches the desktop app
 // ([#627](https://github.com/Omega-JS-Stack/omega/issues/627)): the build
-// workflow's env block, the bundle task's bake, and `omega push-secrets` all read
-// `delivery: { desktop: … }` and nothing else. Each used to carry its own
+// workflow's env block, the bundle task's bake, and the deploy precheck's
+// secrets publish all read `delivery: { desktop: … }` and nothing else. Each
+// used to carry its own
 // hand-kept list — the workflow's was 21 lines a human maintained across four
 // job/step blocks, and a key added to one never reached the others.
 //
@@ -15,12 +16,13 @@ const os = require('os');
 const jetpack = require('fs-jetpack');
 
 const { publishSecretKeys, bakeKeys, renderSecretsBlock, WORKFLOW_OWNED_KEYS } = require('../../../vendor/config/env-delivery.js');
+const { composeTargetEnv } = require('../../../vendor/config/index.js');
 
 const SRC = path.join(__dirname, '..', '..', '..');
 const Manager = require(path.join(SRC, 'build.js'));
 const { ensureTarget } = require(path.join(SRC, 'commands', 'lib', 'ensure-target.js'));
 const bundleTask = require(path.join(SRC, 'gulp', 'tasks', 'bundle.js'));
-const pushSecrets = require(path.join(SRC, 'commands', 'push-secrets.js'));
+const { collectTargetSecrets } = require('../../../vendor/devkit/target-secrets.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
 const package = Manager.getPackage('main');
@@ -51,7 +53,7 @@ function tmpBrand(brandEnv) {
 module.exports = defineCases({
   type: 'group',
   layer: 'build',
-  description: 'env delivery (#627) — the workflow block, the bake list, and push-secrets from ONE schema',
+  description: 'env delivery (#627): the workflow block, the bake list, and the secrets publish from ONE schema',
   tests: [
     {
       name: 'the build workflow renders the schema block — every CI key, no hand list, no token left',
@@ -74,8 +76,10 @@ module.exports = defineCases({
           // The two DELIBERATE step-level overrides survive: the mac signing
           // assets are decoded to files, so those two names are paths there,
           // not the base64 secrets the workflow env carries.
-          ctx.expect(workflow).toContain('CSC_LINK:         config/certs/dev-id.p12');
-          ctx.expect(workflow).toContain('APPLE_API_KEY:    config/certs/AuthKey.p8');
+          // Each override is gated on its secret existing (#872): an empty secret
+          // reads as UNSET after the sanitize pass, so a brand with no cert builds unsigned.
+          ctx.expect(workflow).toContain("CSC_LINK:         ${{ secrets.CSC_LINK != '' && 'config/certs/dev-id.p12' || '' }}");
+          ctx.expect(workflow).toContain("APPLE_API_KEY:    ${{ secrets.APPLE_API_KEY != '' && 'config/certs/AuthKey.p8' || '' }}");
         } finally {
           fs.rmSync(tmp, { recursive: true, force: true });
         }
@@ -142,7 +146,7 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'push-secrets pushes the schema DELIVERY set — a key CI never reads stays home',
+      name: 'the secrets publish sends the schema DELIVERY set: a key CI never reads stays home',
       run: (ctx) => {
         const { brand, target } = tmpBrand([
           'GH_TOKEN=brand-token',
@@ -154,9 +158,14 @@ module.exports = defineCases({
         ].join('\n'));
 
         try {
-          const keys = Object.keys(pushSecrets.collectEnvSecrets(target));
-          ctx.expect(keys.sort()).toEqual(['APPLE_TEAM_ID', 'GH_TOKEN', 'GOOGLE_ANALYTICS_SECRET']);
-          ctx.expect(keys.every((key) => publishSecretKeys('desktop').includes(key))).toBe(true);
+          const values = composeTargetEnv({ targetDir: target, target: 'desktop', environment: 'production' }).values;
+          const keys = Object.keys(collectTargetSecrets({ targetDir: target, target: 'desktop' }));
+
+          // OMEGA_ADMIN_KEY is the backend's and stays home; MY_CUSTOM_THING is
+          // a key the schema never declared, so it is the CONSUMER's own and
+          // travels to every target ([#835](https://github.com/Omega-JS-Stack/omega/issues/835)).
+          ctx.expect(keys.sort()).toEqual(['APPLE_TEAM_ID', 'GH_TOKEN', 'GOOGLE_ANALYTICS_SECRET', 'MY_CUSTOM_THING']);
+          ctx.expect(keys.every((key) => publishSecretKeys('desktop', { values }).includes(key))).toBe(true);
         } finally {
           fs.rmSync(brand, { recursive: true, force: true });
         }

package/dist/test/suites/build/env-watch.test.js

@@ -20,20 +20,30 @@ const SRC = path.join(__dirname, '..', '..', '..');
 const serveTask = require(path.join(SRC, 'gulp', 'tasks', 'serve.js'));
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
-// A desktop target inside a brand monorepo, with a company root above it:
-// <root>/company/.env, <root>/brand/.env, <root>/brand/targets/desktop/.
+// A desktop target inside a brand monorepo whose brand names a COMPANY (#677):
+// the parent brand's company/ tree holds the shared .env, and the machine
+// registry line (the parent's own runs write it) is what says where it is.
 function seedBrand() {
   const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-env-watch-')));
-  const companyRoot = path.join(root, 'company');
+  const parentRoot = path.join(root, 'parent');
+  const companyRoot = path.join(parentRoot, 'company');
   const brandRoot = path.join(root, 'brand');
   const targetDir = path.join(brandRoot, 'targets', 'desktop');
 
+  jetpack.write(path.join(parentRoot, 'config', 'omega.json5'), '{ brand: { id: "fixture-co" }, company: { id: "self" } }');
   jetpack.write(path.join(companyRoot, '.env'), '');
-  jetpack.write(path.join(brandRoot, '.omega', 'company.json'), JSON.stringify({ root: companyRoot }));
-  jetpack.write(path.join(brandRoot, 'config', 'omega.json5'), '{ brand: { id: "fixture" }, targets: { desktop: {} } }');
+  jetpack.write(path.join(brandRoot, 'config', 'omega.json5'), '{ brand: { id: "fixture" }, company: { id: "fixture-co" }, targets: { desktop: { type: "desktop" } } }');
+  jetpack.write(path.join(root, 'home', 'brands.json'), JSON.stringify({ 'fixture-co': { root: parentRoot } }));
   jetpack.dir(targetDir);
 
-  return { root, companyRoot, brandRoot, targetDir };
+  const previous = process.env.OMEGA_HOME;
+  process.env.OMEGA_HOME = path.join(root, 'home');
+  const restore = () => {
+    if (previous === undefined) delete process.env.OMEGA_HOME;
+    else process.env.OMEGA_HOME = previous;
+  };
+
+  return { root, companyRoot, brandRoot, targetDir, restore };
 }
 
 module.exports = defineCases({
@@ -44,7 +54,7 @@ module.exports = defineCases({
     {
       name: 'the serve watcher lists company, brand and target — overlays included',
       run: (ctx) => {
-        const { root, companyRoot, brandRoot, targetDir } = seedBrand();
+        const { root, companyRoot, brandRoot, targetDir, restore } = seedBrand();
         const watcher = serveTask.watchEnvSources(targetDir, { environment: 'development' });
 
         try {
@@ -61,6 +71,7 @@ module.exports = defineCases({
           ]);
         } finally {
           watcher.close();
+          restore();
           fs.rmSync(root, { recursive: true, force: true });
         }
       },

package/dist/test/suites/build/esm-only-dependency.test.js

@@ -0,0 +1,127 @@
+// An ESM-only dependency, bundled into main and preload
+// ([#906](https://github.com/Omega-JS-Stack/omega/issues/906)).
+//
+// Both Node bundles are CommonJS (`format: 'cjs'`, `platform: 'node'`), and
+// esbuild rewrites `import.meta` to `{}` in that output: a dependency doing
+// `createRequire(import.meta.url)` was handed `undefined` and threw
+// ERR_INVALID_ARG_VALUE the moment a packaged app booted (found porting an
+// electron-manager app that depends on yargs 18). @omega.js/devkit's `bundle()`
+// composes the answer for every cjs+node build, so nothing here wires it.
+//
+// The proof is a RUN, not a read of the bundle text: the fixture package
+// (@omega.js/devkit's `test/fixtures/esm-only-package`, the one every target
+// proves this with) is installed into a staged project the way a brand installs
+// a dependency, the REAL bundle task builds it, and the emitted bundle is
+// executed under Node exactly as Electron executes `dist/main.bundle.js`.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+const { installEsmOnlyFixture, FIXTURE_NAME, NODE_MARKER } = require('../../../vendor/devkit/test/esm-only-fixture.js');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+const TASK = path.join(SRC, 'gulp', 'tasks', 'bundle.js');
+
+// What each entry prints once it has loaded the ESM-only dependency: the run's
+// whole answer, on one line, so the test reads it out of stdout.
+function probe(name) {
+  return [
+    `const fixture = require(${JSON.stringify(FIXTURE_NAME)});`,
+    `console.log('${name}:' + JSON.stringify({ fileUrl: fixture.fileUrl, viaRequire: fixture.viaRequire, marker: fixture.marker }));`,
+    '',
+  ].join('\n');
+}
+
+// A desktop project with the fixture installed, built by the real task. The
+// task reads its project (package.json / config / dist) from cwd at require
+// time, so the module is flushed and required fresh inside the staged dir, the
+// way every other build suite drives it.
+async function buildStagedProject() {
+  const tmp = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-esm-only-')));
+  fs.writeFileSync(path.join(tmp, 'package.json'), '{ "name": "staged-desktop", "version": "1.0.0" }');
+
+  const write = (relative, contents) => {
+    const full = path.join(tmp, relative);
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, contents);
+  };
+  write('config/omega.json5', `{
+    brand: { id: 'staged', name: 'Staged' },
+    cloud: { config: { apiKey: 'AIza-staged', projectId: 'demo-staged' } },
+    targets: { desktop: { type: 'desktop' } },
+  }`);
+  write('src/main.js', probe('main'));
+  write('src/preload.js', probe('preload'));
+
+  // The dependency as npm installs one: a package directory under the
+  // consumer's own node_modules, found by the bundler's normal resolution.
+  installEsmOnlyFixture(tmp);
+
+  const oldCwd = process.cwd();
+  const flush = () => {
+    for (const key of Object.keys(require.cache)) {
+      if (key.startsWith(SRC + path.sep)) delete require.cache[key];
+    }
+  };
+
+  flush();
+  try {
+    process.chdir(tmp);
+    const task = require(TASK);
+    await new Promise((resolve, reject) => task((error) => (error ? reject(error) : resolve())));
+  } finally {
+    process.chdir(oldCwd);
+    flush();
+  }
+
+  return tmp;
+}
+
+// Run an emitted Node bundle the way Electron runs it: a plain Node process on
+// the file the build wrote.
+function run(file, name) {
+  const ran = spawnSync(process.execPath, [file], { encoding: 'utf8' });
+  const line = (ran.stdout || '').split('\n').find((text) => text.startsWith(`${name}:`));
+
+  return {
+    status: ran.status,
+    stderr: ran.stderr,
+    result: line ? JSON.parse(line.slice(name.length + 1)) : null,
+  };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'an ESM-only dependency bundles into main and preload, and RUNS (#906)',
+  timeout: 180000,
+  tests: [
+    {
+      name: 'main and preload each carry the ESM-only dependency and boot with a real import.meta.url',
+      run: async (ctx) => {
+        const tmp = await buildStagedProject();
+        try {
+          for (const name of ['main', 'preload']) {
+            const bundleFile = path.join(tmp, 'dist', `${name}.bundle.js`);
+            ctx.expect(fs.existsSync(bundleFile)).toBe(true);
+
+            const { status, stderr, result } = run(bundleFile, name);
+            // Without the composed define this is where it ends: createRequire
+            // gets `undefined` and throws before the app's first line.
+            ctx.expect(status).toBe(0);
+            ctx.expect(stderr.includes('ERR_INVALID_ARG_VALUE')).toBe(false);
+
+            ctx.expect(result.marker).toBe(NODE_MARKER);
+            ctx.expect(result.fileUrl.startsWith('file://')).toBe(true);
+            // The require the dependency opened for itself actually works.
+            ctx.expect(result.viaRequire).toBe(true);
+          }
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/build/exec-with-limit.test.js

@@ -0,0 +1,53 @@
+// Build-layer tests for the time-limited command runner. The real limit is
+// minutes; the mechanism is proven with a one-second one against a real child
+// that would sit for 30s.
+
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const { execWithLimit } = require(path.join(__dirname, '..', '..', '..', 'lib', 'sign-helpers', 'exec-with-limit.js'));
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'exec-with-limit — a child that never returns is rejected at the limit and terminated',
+  tests: [
+    {
+      name: 'the limit rejects on its own timer, naming the label and the seconds',
+      run: async (ctx) => {
+        const started = Date.now();
+
+        let threw;
+        try {
+          await execWithLimit('node -e "setTimeout(function () {}, 30000)"', { limitMs: 1000, label: 'signtool' });
+        } catch (e) { threw = e; }
+
+        ctx.expect(threw).toBeDefined();
+        ctx.expect(threw.message).toBe('signtool produced no verdict within 1s and was terminated');
+        // Rejected at the limit, not at the child's leisure.
+        ctx.expect(Date.now() - started).toBeLessThan(5000);
+      },
+    },
+    {
+      name: 'a child that returns in time is untouched, output and all',
+      run: async (ctx) => {
+        ctx.expect(await execWithLimit('node -e "process.stdout.write(\'ok\')"', { limitMs: 10000 })).toBe('ok');
+
+        // The child's own failure is the child's own error.
+        let threw;
+        try {
+          await execWithLimit('node -e "console.error(\'bad input\'); process.exit(2)"', { limitMs: 10000 });
+        } catch (e) { threw = e; }
+        ctx.expect(threw.message).toMatch(/bad input/);
+      },
+    },
+    {
+      name: 'a missing limit is a programmer error, refused up front',
+      run: (ctx) => {
+        let threw;
+        try { execWithLimit('node -v', {}); } catch (e) { threw = e; }
+        ctx.expect(threw.message).toMatch(/positive limitMs/);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/finalize-release.test.js

@@ -88,8 +88,8 @@ module.exports = defineCases({
         const finalizeRelease = require(path.join(__dirname, '..', '..', '..', 'commands', 'finalize-release.js'));
         const { brandRoot, targetDir } = stageBrand({
           brand: { id: 'acme' },
-          repo: { providers: { github: { org: 'Acme-Org' } } },
-          targets: { desktop: { releases: {} } },
+          repo: { provider: 'github', org: 'Acme-Org' },
+          targets: { desktop: { type: 'desktop', releases: {} } },
         });
         fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify({ name: 'acme-desktop', version: '1.2.3' }));