@hominis/fireforge 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.23.0
+
+- Improved xpcshell test argument filtering and mixed-harness diagnostics.
+- Locked pre-test build phases and improved stale harness diagnostics.
+- Fixed binary-safe re-export for new untracked files.
+- Improved additive `re-export --files` and lint warning guidance.
+
 ## 0.22.0
 
 - Added `doctor --clear-resolution` with verify-backed safety checks.

package/dist/src/commands/lint.js

@@ -161,6 +161,12 @@ async function resolveLintDiff(engineDir, files, binaryName, furnacePrefixes) {
     }
     return diff;
 }
+function buildMaxWarningsMessage(count, maxWarnings, scope) {
+    const scoped = scope ? ` ${scope}` : '';
+    const base = `Patch lint found ${count} warning(s)${scoped}, exceeding --max-warnings ${maxWarnings}.`;
+    return (base +
+        ' If this is a release gate and the warnings are historical patch-size advisories, run with --per-patch to identify the owning patch and split/re-export that patch, or add a scoped lintIgnore entry only after review.');
+}
 /**
  * Filters aggregate-mode lint issues against per-patch `lintIgnore`
  * lists drawn from the manifest. An issue is dropped when at least one
@@ -373,7 +379,7 @@ export async function lintCommand(projectRoot, files, options = {}) {
     }
     if (options.maxWarnings !== undefined && warnings.length > options.maxWarnings) {
         outro('Lint failed');
-        throw new GeneralError(`Patch lint found ${warnings.length} warning(s), exceeding --max-warnings ${options.maxWarnings}.`);
+        throw new GeneralError(buildMaxWarningsMessage(warnings.length, options.maxWarnings));
     }
     // Notices are advisory and don't count as warnings — emitting "passed
     // with warnings" when only notices fired contradicts the preceding
@@ -493,7 +499,7 @@ async function lintPerPatch(projectRoot, paths, options = {}) {
     }
     if (options.maxWarnings !== undefined && warnings.length > options.maxWarnings) {
         outro('Lint failed');
-        throw new GeneralError(`Patch lint found ${warnings.length} warning(s) across ${linted} patch(es), exceeding --max-warnings ${options.maxWarnings}.`);
+        throw new GeneralError(buildMaxWarningsMessage(warnings.length, options.maxWarnings, `across ${linted} patch(es)`));
     }
     if (warnings.length > 0) {
         outro('Lint passed with warnings');

package/dist/src/commands/re-export-files.js

@@ -175,9 +175,10 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
             forceUnsafe: options.forceUnsafe === true,
         });
     }
-    // Shrinks are destructive (previously-owned files become unmanaged).
-    // Additive-only changes still deserve a prompt because --files asserts
-    // an authoritative file set.
+    // Shrinks are destructive (previously-owned files become unmanaged), so
+    // they keep the explicit confirmation gate. Additive-only scopes are safe
+    // to run non-interactively after lint/policy projection because no existing
+    // patch ownership is being dropped.
     const summary = [
         `re-export ${target.filename} with --files scope`,
         `current files (${target.filesAffected.length}): ${target.filesAffected.join(', ') || '(none)'}`,
@@ -196,7 +197,7 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         operation: 're-export-files',
         title: `Re-export ${target.filename} with --files`,
         summary,
-        yes: options.yes === true,
+        yes: removed.length === 0 && missingFiles.length === 0 ? true : options.yes === true,
         dryRun: isDryRun,
         unsafeOverride: options.forceUnsafe === true,
         conflicts,

package/dist/src/commands/test.js

@@ -2,11 +2,11 @@
 import { join } from 'node:path';
 import { prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
-import { buildArtifactMismatchMessage, buildUI, hasBuildArtifacts, hasRunnableBundle, testWithOutput, } from '../core/mach.js';
+import { buildArtifactMismatchMessage, buildUI, hasBuildArtifacts, hasRunnableBundle, testWithOutput, withBuildLock, } from '../core/mach.js';
 import { assertMarionettePortAvailable, extractForwardedMarionettePort, forwardedMachArgsIncludeMarionetteClient, shouldAutoForwardMarionettePortToMach, } from '../core/marionette-port.js';
 import { formatMarionettePreflightLine, reportMarionettePreflight, runMarionettePreflight, } from '../core/marionette-preflight.js';
 import { checkStaleBuildForTest, formatStaleBuildWarning } from '../core/test-stale-check.js';
-import { operatorAlreadySetAppPath, resolveXpcshellAppdirArg, } from '../core/xpcshell-appdir.js';
+import { findNearestXpcshellManifest, operatorAlreadySetAppPath, resolveXpcshellAppdirArg, } from '../core/xpcshell-appdir.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { pathExists } from '../utils/fs.js';
@@ -36,6 +36,43 @@ function buildStaleBuildMessage() {
         'The failing output referenced missing branding or distribution resources, which usually means the current obj-* build does not match recent engine or branding changes.\n\n' +
         'Re-run "fireforge build --ui" or "fireforge test --build" and then retry.');
 }
+async function classifyTestHarnesses(engineDir, normalizedPaths) {
+    const result = { xpcshell: [], nonXpcshell: [] };
+    for (const testPath of normalizedPaths) {
+        const manifest = await findNearestXpcshellManifest(engineDir, testPath);
+        if (manifest) {
+            result.xpcshell.push(testPath);
+        }
+        else {
+            result.nonXpcshell.push(testPath);
+        }
+    }
+    return result;
+}
+function buildMixedHarnessMessage(classification) {
+    return ('FireForge cannot run xpcshell and browser/mochitest paths in the same mach invocation.\n\n' +
+        'Split this into separate `fireforge test` commands so each manifest selects its own harness:\n' +
+        `  - xpcshell: ${classification.xpcshell.join(', ')}\n` +
+        `  - browser/mochitest: ${classification.nonXpcshell.join(', ')}`);
+}
+function filterRedundantXpcshellFlavorArgs(machArgs, classification) {
+    if (classification.xpcshell.length === 0 || classification.nonXpcshell.length > 0) {
+        return [...machArgs];
+    }
+    const filtered = [];
+    for (let i = 0; i < machArgs.length; i += 1) {
+        const arg = machArgs[i] ?? '';
+        if (/^--flavor=xpcshell(?:-tests)?$/.test(arg)) {
+            continue;
+        }
+        if (arg === '--flavor' && /^xpcshell(?:-tests)?$/.test(machArgs[i + 1] ?? '')) {
+            i += 1;
+            continue;
+        }
+        filtered.push(arg);
+    }
+    return filtered;
+}
 function hasStaleBuildArtifactsSignal(output) {
     // Deliberately narrow: only fire on branding-specific resource paths
     // that are always a stale-artifact symptom. The earlier pattern also
@@ -101,6 +138,36 @@ function buildXpcshellAppdirMessage(injectionAttempted) {
         '  - Remove `firefox-appdir = "browser"` from the xpcshell.toml [DEFAULT] and move browser-chrome dependencies into a browser-chrome mochitest (see `fireforge furnace create --test-style=browser-chrome`).\n' +
         '  - If the test only touches toolkit chrome (chrome://global/*), drop the `firefox-appdir` setting entirely — toolkit chrome is registered without it.');
 }
+function buildMochitestSymlinkMessage() {
+    return ('mach failed while preparing mochitest harness symlinks before the requested tests ran.\n\n' +
+        'This usually means the objdir contains stale harness setup from an earlier run. Re-run with `fireforge test --build` to refresh the harness state, or remove the stale mochitest symlink in the active obj-* directory before retrying.');
+}
+async function resolveLaunchablePathForTests(engineDir, binaryName, objDir) {
+    if (!objDir)
+        return undefined;
+    const bundleCheck = await hasRunnableBundle(engineDir, binaryName, objDir);
+    if (!bundleCheck.runnable) {
+        const expectedSuffix = bundleCheck.expectedPath
+            ? ` (expected at engine/${bundleCheck.expectedPath})`
+            : '';
+        throw new GeneralError(`Tests require a complete launchable build${expectedSuffix}. ` +
+            'The obj-*/dist/ tree exists but the launchable binary is missing — typically the result of an interrupted or partially failed `fireforge build`.\n\n' +
+            'Run "fireforge build" again and let it finish before retrying "fireforge test".');
+    }
+    return bundleCheck.expectedPath;
+}
+async function runPreTestBuild(projectRoot, paths, projectConfig) {
+    await withBuildLock(projectRoot, async () => {
+        await prepareBuildEnvironment(projectRoot, paths, projectConfig);
+        const s = spinner('Running incremental build...');
+        const buildResult = await buildUI(paths.engine);
+        if (buildResult.exitCode !== 0) {
+            s.error('Pre-test build failed');
+            throw new BuildError('Pre-test build failed', 'mach build faster');
+        }
+        s.stop('Build complete');
+    });
+}
 // Detects the `AttributeError: 'MochitestDesktop' object has no attribute
 // 'http3Server'` teardown crash. The attribute is lazy-initialized inside
 // harness code paths that presume chrome://branding resolves correctly; a
@@ -153,6 +220,9 @@ function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted
     if (hasMochitestHttp3ServerSignal(combinedOutput)) {
         throw new GeneralError(buildMochitestHttp3ServerMessage());
     }
+    if (/FileExistsError/i.test(combinedOutput) && /mochitest/i.test(combinedOutput)) {
+        throw new GeneralError(buildMochitestSymlinkMessage());
+    }
     if (/invalid filename/i.test(combinedOutput) ||
         /chrome:\/\/mochitests.*not found/i.test(combinedOutput)) {
         info('Hint: The test file may not be registered in browser.toml or jar.mn.');
@@ -201,29 +271,10 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // here so `test --doctor` against an incomplete build surfaces the
     // missing-bundle path instead of a cryptic `Browser process exited
     // during spawn (exit code 1, signal none). stderr tail: (empty)`.
-    let launchablePath;
-    if (buildCheck.objDir) {
-        const bundleCheck = await hasRunnableBundle(paths.engine, projectConfig.binaryName, buildCheck.objDir);
-        launchablePath = bundleCheck.expectedPath;
-        if (!bundleCheck.runnable) {
-            const expectedSuffix = bundleCheck.expectedPath
-                ? ` (expected at engine/${bundleCheck.expectedPath})`
-                : '';
-            throw new GeneralError(`Tests require a complete launchable build${expectedSuffix}. ` +
-                'The obj-*/dist/ tree exists but the launchable binary is missing — typically the result of an interrupted or partially failed `fireforge build`.\n\n' +
-                'Run "fireforge build" again and let it finish before retrying "fireforge test".');
-        }
-    }
+    const launchablePath = await resolveLaunchablePathForTests(paths.engine, projectConfig.binaryName, buildCheck.objDir);
     // Run incremental build if requested
     if (options.build) {
-        await prepareBuildEnvironment(projectRoot, paths, projectConfig);
-        const s = spinner('Running incremental build...');
-        const buildResult = await buildUI(paths.engine);
-        if (buildResult.exitCode !== 0) {
-            s.error('Pre-test build failed');
-            throw new BuildError('Pre-test build failed', 'mach build faster');
-        }
-        s.stop('Build complete');
+        await runPreTestBuild(projectRoot, paths, projectConfig);
         info('');
     }
     else {
@@ -309,6 +360,13 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // previous case-insensitive + leading-whitespace-tolerant contract.
     const normalizedPaths = testPaths.map((p) => stripEnginePrefix(p).trim());
     await assertTestPathsExist(paths.engine, normalizedPaths);
+    const classification = await classifyTestHarnesses(paths.engine, normalizedPaths);
+    if (classification.xpcshell.length > 0 && classification.nonXpcshell.length > 0) {
+        throw new GeneralError(buildMixedHarnessMessage(classification));
+    }
+    const forwardedMachArgs = options.machArg && options.machArg.length > 0
+        ? filterRedundantXpcshellFlavorArgs(options.machArg, classification)
+        : [];
     // Build extra args
     const extraArgs = [];
     if (options.headless) {
@@ -319,8 +377,8 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // above for the motivating case). Appended AFTER --headless so mach sees
     // the FireForge-managed flags first and the escape-valve ones last, which
     // keeps the override precedence predictable.
-    if (options.machArg && options.machArg.length > 0) {
-        extraArgs.push(...options.machArg);
+    if (forwardedMachArgs.length > 0) {
+        extraArgs.push(...forwardedMachArgs);
     }
     // Auto-forward the Marionette port to mach when `--marionette-port` is
     // set. `--setpref=marionette.port=<n>` configures where the browser

package/dist/src/core/git-diff.js

@@ -8,7 +8,7 @@ import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { exec } from '../utils/process.js';
 import { ensureGit, git } from './git-base.js';
-import { fileExistsInHead } from './git-file-ops.js';
+import { fileExistsInHead, isBinaryFile } from './git-file-ops.js';
 import { getUntrackedFiles, getUntrackedFilesInDir } from './git-status.js';
 async function execGitWithAllowedExitCodes(repoDir, args, allowedExitCodes = [0]) {
     const result = await exec('git', args, { cwd: repoDir });
@@ -174,7 +174,9 @@ export async function getAllDiff(repoDir) {
     // Generate diffs for untracked files
     const untrackedDiffs = [];
     for (const file of untrackedFiles) {
-        const diff = await generateNewFileDiff(repoDir, file);
+        const diff = (await isBinaryFile(repoDir, file))
+            ? await generateBinaryFilePatch(repoDir, file)
+            : await generateNewFileDiff(repoDir, file);
         untrackedDiffs.push(diff);
     }
     // Combine all diffs — each already ends with \n, so concatenate directly
@@ -247,7 +249,9 @@ export async function getDiffForFilesAgainstHead(repoDir, files) {
             }
             continue;
         }
-        const diff = await generateNewFileDiff(repoDir, file);
+        const diff = (await isBinaryFile(repoDir, file))
+            ? await generateBinaryFilePatch(repoDir, file)
+            : await generateNewFileDiff(repoDir, file);
         if (diff.trim()) {
             diffs.push(diff);
         }

package/dist/src/core/marionette-port.js

@@ -291,9 +291,12 @@ export function forwardedMachArgsIncludeMarionetteClient(machArgs) {
  * for runs where the pref is ignored anyway.
  */
 export function hasExplicitXpcshellFlavor(machArgs) {
-    for (const arg of machArgs) {
+    for (let i = 0; i < machArgs.length; i += 1) {
+        const arg = machArgs[i] ?? '';
         if (/^--flavor=xpcshell\b/.test(arg) || arg === '--flavor=xpcshell-tests')
             return true;
+        if (arg === '--flavor' && /^xpcshell(?:-tests)?$/.test(machArgs[i + 1] ?? ''))
+            return true;
     }
     return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -66,7 +66,7 @@
     "@vitest/coverage-v8": "^4.1.2",
     "eslint": "^10.0.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint-plugin-jsdoc": "^63.0.0",
     "eslint-plugin-simple-import-sort": "^13.0.0",
     "fast-check": "^4.6.0",
     "husky": "^9.1.7",