@hominis/fireforge 0.15.6 → 0.15.7

package/dist/src/core/mach-build-artifacts.js

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { readdir } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
+import { join, relative, resolve, sep } from 'node:path';
 import { toError } from '../utils/errors.js';
-import { pathExists, readJson } from '../utils/fs.js';
+import { pathExists, readJson, writeJson } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { isObject, isString } from '../utils/validation.js';
 function validateBuildMozinfo(data) {
@@ -112,6 +112,107 @@ export function buildArtifactMismatchMessage(engineDir, buildCheck, commandName)
     }
     return (`${commandName} cannot use copied or relocated build artifacts whose metadata still points at a different Firefox workspace.\n\n` +
         `${details.join('\n')}\n\n` +
-        'Delete the stale obj-* directory in this workspace and run "fireforge build" again so mach regenerates build metadata for the current checkout.');
+        'Delete the stale obj-* directory in this workspace and run "fireforge build" again so mach regenerates build metadata for the current checkout.\n' +
+        'If the workspace was simply moved (same tree, different prefix), "fireforge build --rewrite-mozinfo" will patch mozinfo.json paths in place and run mach configure instead of scrubbing the whole tree.');
+}
+/**
+ * Safe-relocation rewriter for mozinfo.json under the active obj-* tree.
+ *
+ * Firefox build artefacts bake the topsrcdir into many generated files
+ * (Makefiles, config.status, backend.mk, .deps dependency files — anything
+ * produced by `mach configure`). A fresh `mach configure` rebuilds those
+ * from the top, so the rewriter only needs to patch the one file `mach`
+ * reads to learn where its checkout actually lives. Once mozinfo.json
+ * agrees with the on-disk layout, `mach configure` regenerates the rest.
+ *
+ * Safety rules — the rewrite is refused when any of them are violated:
+ *   - `topsrcdir` and `topobjdir` must both be present and non-empty.
+ *   - `topobjdir` must resolve to `<topsrcdir>/<objDir>`; a non-in-tree
+ *     objdir means the previous workspace was configured differently,
+ *     so a blind prefix-rewrite could point mach at the wrong tree.
+ *   - The computed new `topobjdir` must be `<engineDir>/<objDir>`; if it
+ *     is not, the objDir name itself changed and we cannot prove safety.
+ *
+ * When any rule trips, the caller should fall back to the clean-rebuild
+ * instruction — that's always a correct (if expensive) recovery path.
+ *
+ * @param engineDir Absolute path to the current engine checkout.
+ * @param objDir Name of the obj-* directory to rewrite against.
+ * @returns Result object; callers inspect `rewritten` and surface `reason`.
+ */
+export async function attemptMozinfoRewrite(engineDir, objDir) {
+    const mozinfoPath = join(engineDir, objDir, 'mozinfo.json');
+    if (!(await pathExists(mozinfoPath))) {
+        return { rewritten: false, reason: 'mozinfo.json not found in obj directory' };
+    }
+    let raw;
+    try {
+        raw = await readJson(mozinfoPath);
+    }
+    catch (error) {
+        return { rewritten: false, reason: `mozinfo.json is unreadable: ${toError(error).message}` };
+    }
+    if (!isObject(raw)) {
+        return { rewritten: false, reason: 'mozinfo.json is not a JSON object' };
+    }
+    let mozinfo;
+    try {
+        mozinfo = validateBuildMozinfo(raw);
+    }
+    catch (error) {
+        return { rewritten: false, reason: toError(error).message };
+    }
+    const oldSrc = mozinfo.topsrcdir;
+    const oldObj = mozinfo.topobjdir;
+    if (!oldSrc || !oldObj) {
+        return {
+            rewritten: false,
+            reason: 'mozinfo.json is missing topsrcdir or topobjdir; cannot rewrite safely',
+        };
+    }
+    const oldSrcResolved = resolve(oldSrc);
+    const oldObjResolved = resolve(oldObj);
+    const insideTree = oldObjResolved === oldSrcResolved ||
+        oldObjResolved.startsWith(oldSrcResolved + sep) ||
+        oldObjResolved.startsWith(oldSrcResolved + '/');
+    if (!insideTree) {
+        return {
+            rewritten: false,
+            reason: `topobjdir (${oldObjResolved}) is not inside topsrcdir (${oldSrcResolved}) — rewrite would change workspace layout`,
+        };
+    }
+    const relativeObj = relative(oldSrcResolved, oldObjResolved).split(sep).join('/');
+    if (relativeObj !== objDir) {
+        return {
+            rewritten: false,
+            reason: `mozinfo objdir "${relativeObj}" does not match detected objdir "${objDir}" — rewrite would change the obj directory name`,
+        };
+    }
+    const newSrc = resolve(engineDir);
+    const newObj = resolve(engineDir, objDir);
+    const patched = { ...raw, topsrcdir: newSrc, topobjdir: newObj };
+    let newMozconfig;
+    if (mozinfo.mozconfig) {
+        const oldMozconfigResolved = resolve(mozinfo.mozconfig);
+        if (oldMozconfigResolved === oldSrcResolved ||
+            oldMozconfigResolved.startsWith(oldSrcResolved + sep) ||
+            oldMozconfigResolved.startsWith(oldSrcResolved + '/')) {
+            const rel = relative(oldSrcResolved, oldMozconfigResolved);
+            newMozconfig = resolve(newSrc, rel);
+            patched['mozconfig'] = newMozconfig;
+        }
+        // A mozconfig living outside the old topsrcdir is left as-is — it
+        // probably points at a shared configuration file the user kept in
+        // place across the relocation. A relocated checkout that also moved
+        // its mozconfig will still fail configure; operator can re-point
+        // with `MOZCONFIG=…` or run a full clean rebuild.
+    }
+    await writeJson(mozinfoPath, patched);
+    return {
+        rewritten: true,
+        newTopsrcdir: newSrc,
+        newTopobjdir: newObj,
+        ...(newMozconfig ? { newMozconfig } : {}),
+    };
 }
 //# sourceMappingURL=mach-build-artifacts.js.map

package/dist/src/core/mach.d.ts

@@ -1,4 +1,4 @@
-export { type BuildArtifactCheck, buildArtifactMismatchMessage, hasBuildArtifacts, } from './mach-build-artifacts.js';
+export { attemptMozinfoRewrite, type BuildArtifactCheck, buildArtifactMismatchMessage, hasBuildArtifacts, type MozinfoRewriteResult, } from './mach-build-artifacts.js';
 export { generateMozconfig, type MozconfigVariables } from './mach-mozconfig.js';
 export { ensurePython, resetResolvedPython } from './mach-python.js';
 /**

package/dist/src/core/mach.js

@@ -7,7 +7,7 @@ import { exec, execInherit, execInheritCapture, execStream } from '../utils/proc
 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.
-export { buildArtifactMismatchMessage, hasBuildArtifacts, } from './mach-build-artifacts.js';
+export { attemptMozinfoRewrite, buildArtifactMismatchMessage, hasBuildArtifacts, } from './mach-build-artifacts.js';
 export { generateMozconfig } from './mach-mozconfig.js';
 export { ensurePython, resetResolvedPython } from './mach-python.js';
 /**

package/dist/src/core/test-stale-check.d.ts

@@ -0,0 +1,42 @@
+import type { BuildBaseline } from './build-baseline.js';
+/** Result of the stale-build preflight probe. */
+export interface StaleBuildResult {
+    /** True when at least one packageable engine file changed since the baseline. */
+    stale: boolean;
+    /**
+     * Engine-relative paths that would have been packaged but appear to have
+     * changed since the baseline. Sorted and deduplicated. Truncated at
+     * {@link STALE_PATHS_LIMIT} entries for rendering; consult
+     * {@link StaleBuildResult.truncated} to know when to append a `(+N more)`
+     * tail to the warning.
+     */
+    changedPaths: string[];
+    /**
+     * How many paths were dropped from `changedPaths` due to the render cap.
+     * Callers render this as `(+N more)` in the warning body.
+     */
+    truncated: number;
+    /**
+     * The baseline that anchored the diff, or undefined when no previous
+     * successful build exists. A missing baseline is treated as "not stale"
+     * — we have nothing to compare against and a warning would mislead.
+     */
+    baseline: BuildBaseline | undefined;
+}
+/**
+ * Probes the engine tree for packageable changes since the last successful
+ * `fireforge build`. Returns a summary the `fireforge test` handler renders
+ * as an up-front warning when `--build` was NOT passed. The probe never
+ * throws; git failures and a missing baseline both degrade to `stale: false`
+ * so a broken probe cannot block a test run.
+ *
+ * @param projectRoot Root directory of the project.
+ * @param engineDir Path to the engine directory.
+ */
+export declare function checkStaleBuildForTest(projectRoot: string, engineDir: string): Promise<StaleBuildResult>;
+/**
+ * Formats a human-readable warning body from a {@link StaleBuildResult}.
+ * Kept separate from the probe so test code can assert on the structured
+ * result without matching the rendered copy.
+ */
+export declare function formatStaleBuildWarning(result: StaleBuildResult): string;

package/dist/src/core/test-stale-check.js

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: EUPL-1.2
+/*
+ * Stale-build preflight for `fireforge test`.
+ *
+ * Without this preflight, an operator who edits engine chrome / packaged
+ * resources (`jar.mn` entries, `.xhtml`/`.mjs`/`.css` under chrome trees,
+ * pref files) and then runs `fireforge test <path>` only discovers the
+ * build is stale AFTER xpcshell / mach test starts and errors out with
+ * `NS_ERROR_FILE_NOT_FOUND` against a `chrome://browser/content/…` URI
+ * — which reads as a test bug, not a rebuild prompt. The motivating case
+ * was scaffolding a new top-level chrome document + BrowserGlue-style
+ * xpcshell test: the test file existed, the manifests were registered,
+ * but `dist/` still held the pre-edit bundle and chrome URIs resolved
+ * to nothing.
+ *
+ * This preflight diffs engine HEAD (or workdir) against the last-build
+ * baseline (`.fireforge/last-build.json`), filters to paths that imply
+ * packaging, and returns a compact summary. `fireforge test` prints a
+ * warning up-front so the operator sees "you edited X, Y, Z since the
+ * last build — rerun with `--build` to refresh" BEFORE mach test
+ * launches. Detection stays advisory (warn-only) because a fork that
+ * rebuilds out-of-band (a separate `./mach build` invocation, an IDE
+ * plugin, etc.) can legitimately have a fresh `dist/` with no
+ * FireForge-recorded baseline update.
+ */
+import { toError } from '../utils/errors.js';
+import { verbose } from '../utils/logger.js';
+import { isPackageablePath } from './build-audit.js';
+import { readBuildBaseline } from './build-baseline.js';
+import { hasChanges, isMissingHeadError } from './git.js';
+import { git } from './git-base.js';
+import { getUntrackedFiles } from './git-status.js';
+/** Cap on the number of changed paths rendered inline. */
+const STALE_PATHS_LIMIT = 10;
+/**
+ * Collects engine paths that changed since the baseline SHA plus any
+ * workdir modifications. Mirrors the helper inside `build-prepare.ts` but
+ * is kept separate so the test-side preflight does not need to pull in
+ * the full build-prepare dependency graph (mozconfig generation, furnace
+ * apply hooks, …).
+ */
+async function collectChangedEnginePaths(engineDir, baseline) {
+    const collected = new Set();
+    if (baseline.engineHeadSha) {
+        try {
+            const diff = await git(['diff', '--name-only', `${baseline.engineHeadSha}..HEAD`], engineDir);
+            for (const line of diff.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    collected.add(trimmed);
+            }
+        }
+        catch (error) {
+            if (!isMissingHeadError(error)) {
+                verbose(`Stale-build preflight: could not diff engine against baseline — ${toError(error).message}`);
+            }
+        }
+    }
+    try {
+        if (await hasChanges(engineDir)) {
+            const worktreeDiff = await git(['diff', '--name-only', 'HEAD'], engineDir);
+            for (const line of worktreeDiff.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    collected.add(trimmed);
+            }
+            for (const untracked of await getUntrackedFiles(engineDir)) {
+                collected.add(untracked);
+            }
+        }
+    }
+    catch (error) {
+        verbose(`Stale-build preflight: could not enumerate workdir changes — ${toError(error).message}`);
+    }
+    return [...collected];
+}
+/**
+ * Probes the engine tree for packageable changes since the last successful
+ * `fireforge build`. Returns a summary the `fireforge test` handler renders
+ * as an up-front warning when `--build` was NOT passed. The probe never
+ * throws; git failures and a missing baseline both degrade to `stale: false`
+ * so a broken probe cannot block a test run.
+ *
+ * @param projectRoot Root directory of the project.
+ * @param engineDir Path to the engine directory.
+ */
+export async function checkStaleBuildForTest(projectRoot, engineDir) {
+    const baseline = await readBuildBaseline(projectRoot);
+    if (!baseline) {
+        return { stale: false, changedPaths: [], truncated: 0, baseline: undefined };
+    }
+    const changed = await collectChangedEnginePaths(engineDir, baseline);
+    const packageable = changed.filter((path) => isPackageablePath(path)).sort();
+    if (packageable.length === 0) {
+        return { stale: false, changedPaths: [], truncated: 0, baseline };
+    }
+    const head = packageable.slice(0, STALE_PATHS_LIMIT);
+    const truncated = Math.max(0, packageable.length - head.length);
+    return { stale: true, changedPaths: head, truncated, baseline };
+}
+/**
+ * Formats a human-readable warning body from a {@link StaleBuildResult}.
+ * Kept separate from the probe so test code can assert on the structured
+ * result without matching the rendered copy.
+ */
+export function formatStaleBuildWarning(result) {
+    const tail = result.truncated > 0 ? `, … (+${result.truncated} more)` : '';
+    const list = result.changedPaths.join(', ') + tail;
+    return (`Engine tree has changed since the last successful fireforge build (${list}).\n` +
+        'The current obj-*/dist/ bundle may not reflect those edits. If your test reads ' +
+        'packaged chrome / jar.mn resources, rerun with "fireforge test --build" (or ' +
+        '"fireforge build --ui") first. Passing --build skips this check.');
+}
+//# sourceMappingURL=test-stale-check.js.map

package/dist/src/types/commands/options.d.ts

@@ -41,6 +41,14 @@ export interface BuildOptions {
     jobs?: number;
     /** Brand to build (stable, esr, etc.) */
     brand?: string;
+    /**
+     * When a mozinfo mismatch is detected that looks like a safe path
+     * relocation (same structure, different prefix), patch mozinfo paths
+     * in place and run `mach configure` rather than aborting with a
+     * full-rebuild instruction. Falls back to the original abort message
+     * for any mismatch the rewriter cannot prove safe.
+     */
+    rewriteMozinfo?: boolean;
 }
 /**
  * Options for the export command.
@@ -298,6 +306,14 @@ export interface FurnaceCreateOptions {
     testStyle?: 'mochikit' | 'browser-chrome' | 'xpcshell';
     /** Stock component tag names composed internally by this component */
     compose?: string[];
+    /**
+     * Show the planned file set and furnace.json changes without writing
+     * anything. All validation that does not require disk writes (tag name
+     * shape, name conflicts, engine pre-existence, `--compose` targets, cycle
+     * detection, prefix warning) runs before the plan is emitted, so a
+     * dry-run faithfully previews the real command's outcome.
+     */
+    dryRun?: boolean;
 }
 /**
  * Options for the wire command.

package/package.json

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