@hominis/fireforge 0.28.4 → 0.29.0

package/CHANGELOG.md

@@ -1,7 +1,12 @@
 # Changelog
 
+## 0.29.0
+
+- Improved `fireforge test --build` failure reporting so post-rebuild focused test failures name the rebuild command, requested paths, and first failure line separately from stale-artifact rebuild advice.
+
 ## 0.28.0
 
+- Restored mach lint compatibility for FireForge-managed Git-backed Firefox checkouts by materializing a `.hgignore` copy of `.gitignore` when Firefox's ignorefile linter config is present.
 - Added the product-resolved Firefox source archive URL to `source set` output so pinned checksums can be verified against the exact archive target before download.
 - Added dry-run locking for `re-export` so parallel previews serialize engine git inspection instead of racing on `.git/index.lock`.
 - Added `re-export --scan --scan-files <manifest>` for dry-runnable bulk generated-file assignment across owner patches, with ambiguity and ownership refusals.

package/dist/src/commands/test.js

@@ -5,9 +5,9 @@ import { getProjectPaths, loadConfig } from '../core/config.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 { buildHarnessEarlyExitMessage, classifyHarnessEarlyExit, } from '../core/test-harness-output.js';
+import { buildHarnessEarlyExitMessage, classifyHarnessEarlyExit, completePostRebuildFailureContext, createPostRebuildFailureContext, prependPostRebuildFailureContext, } from '../core/test-harness-output.js';
 import { checkStaleBuildForTest, formatStaleBuildWarning } from '../core/test-stale-check.js';
-import { tryRepairStaleXpcshellTestSymlink } from '../core/test-stale-symlink.js';
+import { retryAfterXpcshellSymlinkRepair } from '../core/test-xpcshell-retry.js';
 import { findNearestXpcshellManifest } from '../core/xpcshell-appdir.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
@@ -34,7 +34,12 @@ function buildUnknownTestMessage(testPaths) {
         'The file may exist, but Firefox does not currently resolve it as a runnable test.\n\n' +
         'Check the nearest test manifest (for example browser.toml or xpcshell.toml), confirm the file is listed under the correct test type, and make sure each parent moz.build registers that manifest before retrying.');
 }
-function buildStaleBuildMessage() {
+function buildStaleBuildMessage(postRebuild) {
+    if (postRebuild) {
+        return ('Firefox test runtime still reported stale-artifact-shaped resource failures after the rebuild completed.\n\n' +
+            'FireForge already ran the requested rebuild before this focused test, so treat the remaining failure as a real runtime, registration, routing, or test-contract regression rather than another stale deployed-artifact-only blocker.\n\n' +
+            'Check the first post-rebuild failure above and the raw mach output for the concrete path or module that still fails.');
+    }
     return ('Firefox test runtime appears to be using stale build artifacts.\n\n' +
         '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.');
@@ -171,6 +176,15 @@ async function runPreTestBuild(projectRoot, paths, projectConfig) {
         s.stop('Build complete');
     });
 }
+function logTestSelection(normalizedPaths) {
+    if (normalizedPaths.length > 0) {
+        info(`Running tests: ${normalizedPaths.join(', ')}`);
+    }
+    else {
+        info('Running all tests...');
+    }
+    info('');
+}
 // 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
@@ -188,16 +202,23 @@ function buildMochitestHttp3ServerMessage() {
         "  - The `BROWSER_CHROME_MANIFESTS` entry for your fork's chrome.manifest is registered.\n\n" +
         'This is an upstream Firefox harness interaction; FireForge can only diagnose it.');
 }
-function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted, binaryName) {
+function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted, binaryName, postRebuildContext) {
     if (result.exitCode === 0 || result.exitCode === 130)
         return;
     const combinedOutput = `${result.stdout}\n${result.stderr}`;
+    const failureContext = postRebuildContext
+        ? completePostRebuildFailureContext(postRebuildContext, combinedOutput)
+        : undefined;
+    const withContext = (message) => prependPostRebuildFailureContext(message, failureContext);
+    const throwGeneral = (message) => {
+        throw new GeneralError(withContext(message));
+    };
     if (/UNKNOWN TEST\b/i.test(combinedOutput)) {
-        throw new GeneralError(buildUnknownTestMessage(normalizedPaths));
+        throwGeneral(buildUnknownTestMessage(normalizedPaths));
     }
     const earlyExit = classifyHarnessEarlyExit(combinedOutput, normalizedPaths);
     if (earlyExit) {
-        throw new GeneralError(buildHarnessEarlyExitMessage(earlyExit, normalizedPaths));
+        throwGeneral(buildHarnessEarlyExitMessage(earlyExit, normalizedPaths));
     }
     // Fork-owned module load failures must beat the branding stale-build
     // branch: 2026-04-21 eval (Finding #14) saw a fork's test fail with
@@ -206,7 +227,7 @@ function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted
     // stale-build pattern matched, so the operator was told to rebuild
     // when the real fix is to register the missing module.
     if (hasForkModuleSignal(combinedOutput, binaryName)) {
-        throw new GeneralError(buildForkModuleMessage(binaryName));
+        throwGeneral(buildForkModuleMessage(binaryName));
     }
     // Branding-specific stale-build signals keep priority over the broader
     // xpcshell-appdir hint: when `chrome://branding/locale/brand.properties`
@@ -219,24 +240,24 @@ function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted
     // which is the more useful diagnosis in practice for `Failed to load
     // resource:///modules/…`.
     if (hasStaleBuildArtifactsSignal(combinedOutput)) {
-        throw new GeneralError(buildStaleBuildMessage());
+        throwGeneral(buildStaleBuildMessage(Boolean(failureContext)));
     }
     if (hasXpcshellAppdirSignal(combinedOutput)) {
-        throw new GeneralError(buildXpcshellAppdirMessage(appdirInjectionAttempted));
+        throwGeneral(buildXpcshellAppdirMessage(appdirInjectionAttempted));
     }
     if (hasMochitestHttp3ServerSignal(combinedOutput)) {
-        throw new GeneralError(buildMochitestHttp3ServerMessage());
+        throwGeneral(buildMochitestHttp3ServerMessage());
     }
     if (/FileExistsError/i.test(combinedOutput) &&
         /(mochitest|xpcshell|_tests)/i.test(combinedOutput)) {
-        throw new GeneralError(buildHarnessSymlinkMessage());
+        throwGeneral(buildHarnessSymlinkMessage());
     }
     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.');
         info('Run "fireforge register <test-path>" to register it.');
     }
-    throw new BuildError(`Tests failed with exit code ${result.exitCode}. Check the output above for details.`, 'mach test');
+    throw new BuildError(withContext(`Tests failed with exit code ${result.exitCode}. Check the output above for details.`), 'mach test');
 }
 /**
  * Runs the test command to execute mach tests.
@@ -362,10 +383,6 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
             throw new GeneralError('Marionette preflight reported FAIL — see output above. Aborting before mach test runs.');
         }
     }
-    // Normalize test paths (strip engine/ prefix if present). Uses the
-    // shared `stripEnginePrefix` helper so `test`, `register`, `lint`, and
-    // `export` all accept the same prefix forms. Also trim to match the
-    // 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);
@@ -375,7 +392,6 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     const forwardedMachArgs = options.machArg && options.machArg.length > 0
         ? filterRedundantXpcshellFlavorArgs(options.machArg, classification)
         : [];
-    // Build extra args
     const extraArgs = [];
     if (options.headless) {
         extraArgs.push('--headless');
@@ -430,14 +446,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // overrides via `--mach-arg=--app-path=…` always win — we skip injection
     // when the operator already passed one.
     const appdirInjection = await maybeInjectAppdirArg(paths.engine, normalizedPaths, buildCheck.objDir, extraArgs);
-    // Log what we're doing
-    if (normalizedPaths.length > 0) {
-        info(`Running tests: ${normalizedPaths.join(', ')}`);
-    }
-    else {
-        info('Running all tests...');
-    }
-    info('');
+    logTestSelection(normalizedPaths);
     let result;
     try {
         result = await testWithOutput(paths.engine, normalizedPaths, extraArgs);
@@ -445,15 +454,10 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     catch (error) {
         throw new BuildError('Test process failed to start', 'mach test', error instanceof Error ? error : undefined);
     }
-    if (result.exitCode !== 0 &&
-        classification.xpcshell.length > 0 &&
-        classification.nonXpcshell.length === 0) {
-        const repaired = await tryRepairStaleXpcshellTestSymlink(paths.engine, buildCheck.objDir, `${result.stdout}\n${result.stderr}`);
-        if (repaired) {
-            result = await testWithOutput(paths.engine, normalizedPaths, extraArgs);
-        }
-    }
-    handleNonZeroTestExit(result, normalizedPaths, appdirInjection, projectConfig.binaryName);
+    result = await retryAfterXpcshellSymlinkRepair(paths.engine, buildCheck.objDir, result, classification, normalizedPaths, extraArgs);
+    handleNonZeroTestExit(result, normalizedPaths, appdirInjection, projectConfig.binaryName, options.build
+        ? createPostRebuildFailureContext('fireforge test --build', normalizedPaths)
+        : undefined);
 }
 /** Registers the test command on the CLI program. */
 export function registerTest(program, { getProjectRoot, withErrorHandling }) {

package/dist/src/core/firefox-ignorefile.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Result of normalizing Firefox's Mercurial ignore file for Git-backed
+ * checkouts.
+ */
+export type FirefoxIgnorefileCompatibilityResult = 'created' | 'existing' | 'skipped';
+/**
+ * Ensures Firefox's mozlint ignorefile configuration can be parsed in
+ * Git-backed source trees.
+ *
+ * Firefox's `tools/lint/ignorefile.yml` includes both `.gitignore` and
+ * `.hgignore`. Source archives and some Git mirrors may omit `.hgignore`,
+ * which makes `mach lint --fix <files>` fail before it reaches the scoped
+ * linter. For FireForge-managed Git checkouts, copying `.gitignore` gives
+ * mozlint the missing include and keeps the ignorefile linter's pattern
+ * comparison equivalent without patching upstream lint configuration.
+ */
+export declare function ensureFirefoxIgnorefileCompatibility(engineDir: string): Promise<FirefoxIgnorefileCompatibilityResult>;

package/dist/src/core/firefox-ignorefile.js

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+/**
+ * Ensures Firefox's mozlint ignorefile configuration can be parsed in
+ * Git-backed source trees.
+ *
+ * Firefox's `tools/lint/ignorefile.yml` includes both `.gitignore` and
+ * `.hgignore`. Source archives and some Git mirrors may omit `.hgignore`,
+ * which makes `mach lint --fix <files>` fail before it reaches the scoped
+ * linter. For FireForge-managed Git checkouts, copying `.gitignore` gives
+ * mozlint the missing include and keeps the ignorefile linter's pattern
+ * comparison equivalent without patching upstream lint configuration.
+ */
+export async function ensureFirefoxIgnorefileCompatibility(engineDir) {
+    const lintConfigPath = join(engineDir, 'tools', 'lint', 'ignorefile.yml');
+    if (!(await pathExists(lintConfigPath))) {
+        return 'skipped';
+    }
+    const hgignorePath = join(engineDir, '.hgignore');
+    if (await pathExists(hgignorePath)) {
+        return 'existing';
+    }
+    const gitignorePath = join(engineDir, '.gitignore');
+    if (!(await pathExists(gitignorePath))) {
+        return 'skipped';
+    }
+    await writeText(hgignorePath, await readText(gitignorePath));
+    return 'created';
+}
+//# sourceMappingURL=firefox-ignorefile.js.map

package/dist/src/core/git.js

@@ -7,6 +7,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists, removeFile } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { exec } from '../utils/process.js';
+import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
 import { configureGitPerformance, ensureGit, git, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_TIMEOUT_MS, } from './git-base.js';
 import { getWorkingTreeStatus } from './git-status.js';
 // ── Functions that remain in this file ──
@@ -291,6 +292,8 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
     reportProgress('Configuring origin remote for build compatibility...');
     await git(['remote', 'add', 'origin', 'https://github.com/mozilla-firefox/firefox'], dir);
     reportProgress('Git phase complete: source git repository metadata initialized.');
+    reportProgress('Normalizing Firefox ignore files for Git-backed mach lint compatibility...');
+    await ensureFirefoxIgnorefileCompatibility(dir);
     // Add all files
     reportProgress('Indexing Firefox source with git add -A (this can take several minutes on large trees)...');
     await assertNoGitIndexLock(dir);
@@ -327,6 +330,8 @@ export async function resumeRepository(dir, options = {}) {
     await cleanupIndexLock(dir);
     // Ensure origin remote exists (may have been added before the interrupt)
     await ensureOriginRemote(dir);
+    reportProgress('Normalizing Firefox ignore files for Git-backed mach lint compatibility...');
+    await ensureFirefoxIgnorefileCompatibility(dir);
     // Stage all files
     reportProgress('Indexing Firefox source (resuming)...');
     await assertNoGitIndexLock(dir);

package/dist/src/core/mach.js

@@ -5,6 +5,7 @@ import { pathExists } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { exec, execInherit, execInheritCapture, execSmokeRun, execStream, } from '../utils/process.js';
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
+import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
 import { explainMachError } from './mach-error-hints.js';
 import { getPython } from './mach-python.js';
 // Re-export sub-modules so existing `from './mach.js'` imports keep working.
@@ -32,6 +33,7 @@ export async function ensureMach(engineDir) {
 export async function runMach(args, engineDir, options = {}) {
     const python = await getPython(engineDir);
     await ensureMach(engineDir);
+    await ensureFirefoxIgnorefileCompatibility(engineDir);
     const machPath = join(engineDir, 'mach');
     const execOptions = {
         cwd: engineDir,
@@ -59,6 +61,7 @@ const CAPTURE_TAIL_LIMIT = 2 * 1024 * 1024;
 export async function runMachCapture(args, engineDir, options = {}) {
     const python = await getPython(engineDir);
     await ensureMach(engineDir);
+    await ensureFirefoxIgnorefileCompatibility(engineDir);
     const machPath = join(engineDir, 'mach');
     let stdout = '';
     let stderr = '';
@@ -89,6 +92,7 @@ export async function runMachCapture(args, engineDir, options = {}) {
 export async function runMachInheritCapture(args, engineDir, options = {}) {
     const python = await getPython(engineDir);
     await ensureMach(engineDir);
+    await ensureFirefoxIgnorefileCompatibility(engineDir);
     const machPath = join(engineDir, 'mach');
     return execInheritCapture(python, [machPath, ...args], {
         cwd: engineDir,
@@ -237,6 +241,7 @@ export async function run(engineDir, args = []) {
 export async function runMachSmoke(args, engineDir, options) {
     const python = await getPython(engineDir);
     await ensureMach(engineDir);
+    await ensureFirefoxIgnorefileCompatibility(engineDir);
     const machPath = join(engineDir, 'mach');
     return execSmokeRun(python, [machPath, ...args], {
         cwd: engineDir,

package/dist/src/core/test-harness-output.d.ts

@@ -3,6 +3,19 @@ export interface HarnessEarlyExit {
     kind: HarnessEarlyExitKind;
     line: string;
 }
+export interface PostRebuildFailureContext {
+    rebuildCommand: string;
+    requestedPaths: readonly string[];
+    firstFailureLine?: string;
+}
+/** Finds the first high-signal failure line from captured mach test output. */
+export declare function findFirstUsefulFailureLine(output: string): string | undefined;
+/** Starts a post-rebuild context block for a focused test failure. */
+export declare function createPostRebuildFailureContext(rebuildCommand: string, requestedPaths: readonly string[]): PostRebuildFailureContext;
+/** Adds the first useful failure line from captured output to an existing context block. */
+export declare function completePostRebuildFailureContext(context: PostRebuildFailureContext, output: string): PostRebuildFailureContext;
+/** Prepends post-rebuild context when the test failure happened after a successful rebuild. */
+export declare function prependPostRebuildFailureContext(message: string, context: PostRebuildFailureContext | undefined): string;
 /** Classifies mach output where no requested test actually began running. */
 export declare function classifyHarnessEarlyExit(output: string, normalizedPaths: readonly string[]): HarnessEarlyExit | undefined;
 /** Builds the user-facing message for a harness startup or zero-run failure. */

package/dist/src/core/test-harness-output.js

@@ -8,6 +8,45 @@ function getNonEmptyOutputLines(output) {
 function findFirstMatchingLine(lines, patterns) {
     return lines.find((line) => patterns.some((pattern) => pattern.test(line)));
 }
+/** Finds the first high-signal failure line from captured mach test output. */
+export function findFirstUsefulFailureLine(output) {
+    const lines = getNonEmptyOutputLines(output);
+    const matched = findFirstMatchingLine(lines, [
+        /\bTEST-UNEXPECTED-[A-Z-]+\b/,
+        /\bPROCESS-CRASH\b/i,
+        /\bTIMEOUT\b/i,
+        /timed out/i,
+        /HominisBrowserUnavailableError/i,
+        /Marionette.*(?:session|startup|start).*fail/i,
+        /(?:failed|unable) to (?:start|create|open).*Marionette/i,
+        /SessionNotCreatedException/i,
+        /Browser process exited during spawn/i,
+        /Failed to load (?:resource|chrome):\/\//i,
+        /\b(?:Error|Exception|TypeError|ReferenceError|SyntaxError):\s+/,
+        /AttributeError:\s+/,
+    ]);
+    return matched ?? lines[0];
+}
+/** Starts a post-rebuild context block for a focused test failure. */
+export function createPostRebuildFailureContext(rebuildCommand, requestedPaths) {
+    return { rebuildCommand, requestedPaths };
+}
+/** Adds the first useful failure line from captured output to an existing context block. */
+export function completePostRebuildFailureContext(context, output) {
+    const firstFailureLine = findFirstUsefulFailureLine(output);
+    return firstFailureLine ? { ...context, firstFailureLine } : context;
+}
+/** Prepends post-rebuild context when the test failure happened after a successful rebuild. */
+export function prependPostRebuildFailureContext(message, context) {
+    if (!context)
+        return message;
+    const requestedPaths = context.requestedPaths.length > 0 ? context.requestedPaths.join(', ') : '(all tests)';
+    return ('Post-rebuild test failure:\n\n' +
+        `Rebuild command: ${context.rebuildCommand}\n` +
+        `Requested paths: ${requestedPaths}\n` +
+        `First post-rebuild failure: ${context.firstFailureLine ?? '(no captured output)'}\n\n` +
+        message);
+}
 /** Classifies mach output where no requested test actually began running. */
 export function classifyHarnessEarlyExit(output, normalizedPaths) {
     const lines = getNonEmptyOutputLines(output);

package/dist/src/core/test-xpcshell-retry.d.ts

@@ -0,0 +1,7 @@
+import { type MachCommandResult } from './mach.js';
+export interface XpcshellRetryClassification {
+    xpcshell: readonly string[];
+    nonXpcshell: readonly string[];
+}
+/** Removes a stale xpcshell install symlink and retries the focused mach test once. */
+export declare function retryAfterXpcshellSymlinkRepair(engineDir: string, objDir: string | undefined, result: MachCommandResult, classification: XpcshellRetryClassification, normalizedPaths: string[], extraArgs: string[]): Promise<MachCommandResult>;

package/dist/src/core/test-xpcshell-retry.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { testWithOutput } from './mach.js';
+import { tryRepairStaleXpcshellTestSymlink } from './test-stale-symlink.js';
+/** Removes a stale xpcshell install symlink and retries the focused mach test once. */
+export async function retryAfterXpcshellSymlinkRepair(engineDir, objDir, result, classification, normalizedPaths, extraArgs) {
+    if (result.exitCode !== 0 &&
+        classification.xpcshell.length > 0 &&
+        classification.nonXpcshell.length === 0) {
+        const repaired = await tryRepairStaleXpcshellTestSymlink(engineDir, objDir, `${result.stdout}\n${result.stderr}`);
+        if (repaired) {
+            return testWithOutput(engineDir, normalizedPaths, extraArgs);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=test-xpcshell-retry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.28.4",
+  "version": "0.29.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",