@hominis/fireforge 0.9.0

package/dist/src/commands/package.js

@@ -0,0 +1,80 @@
+import { validateBrandOverride } from '../core/brand-validation.js';
+import { prepareBuildEnvironment } from '../core/build-prepare.js';
+import { getProjectPaths, loadConfig } from '../core/config.js';
+import { buildArtifactMismatchMessage, hasBuildArtifacts, machPackage } from '../core/mach.js';
+import { GeneralError } from '../errors/base.js';
+import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
+import { pathExists } from '../utils/fs.js';
+import { error, info, intro, outro, verbose } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Runs the package command to create a distribution package.
+ * @param projectRoot - Root directory of the project
+ * @param options - Package options
+ */
+export async function packageCommand(projectRoot, options) {
+    const brandInfo = options.brand ? ` [${options.brand}]` : '';
+    intro(`FireForge Package${brandInfo}`);
+    // Load configuration
+    const config = await loadConfig(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    validateBrandOverride(config.binaryName, options.brand);
+    // Check if engine exists
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    const buildCheck = await hasBuildArtifacts(paths.engine);
+    if (buildCheck.ambiguous && buildCheck.objDirs && buildCheck.objDirs.length > 0) {
+        throw new AmbiguousBuildArtifactsError(buildCheck.objDirs);
+    }
+    const mismatchMessage = buildArtifactMismatchMessage(paths.engine, buildCheck, 'Package');
+    if (mismatchMessage) {
+        throw new GeneralError(mismatchMessage);
+    }
+    if (!buildCheck.exists) {
+        const detail = buildCheck.objDir
+            ? `Build artifacts incomplete in ${buildCheck.objDir}/`
+            : 'No build artifacts found (obj-*/ directory missing)';
+        throw new GeneralError(`Packaging requires a completed build. ${detail}\n\n` +
+            "Run 'fireforge build' first, then rerun 'fireforge package'.");
+    }
+    // Log brand info if specified
+    if (options.brand) {
+        verbose(`Packaging with brand: ${options.brand}`);
+        info(`Brand: ${options.brand}`);
+    }
+    // Shared pre-flight: branding, Furnace, mozconfig
+    await prepareBuildEnvironment(projectRoot, paths, config);
+    // Run package
+    info('Creating distribution package...');
+    info('This may take a while.\n');
+    const startTime = Date.now();
+    let exitCode;
+    try {
+        exitCode = await machPackage(paths.engine);
+    }
+    catch (error) {
+        throw new BuildError('Package process failed to start', 'mach package', error instanceof Error ? error : undefined);
+    }
+    const duration = Date.now() - startTime;
+    const minutes = Math.floor(duration / 60000);
+    const seconds = Math.floor((duration % 60000) / 1000);
+    const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+    if (exitCode !== 0) {
+        error(`Packaging failed after ${timeStr}`);
+        throw new BuildError(`Packaging failed with exit code ${exitCode}`, 'mach package');
+    }
+    info(`\nPackage created in obj-*/dist/`);
+    outro(`Packaging completed in ${timeStr}!`);
+}
+/** Registers the package command on the CLI program. */
+export function registerPackage(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('package')
+        .description('Create distribution package')
+        .option('--brand <name>', 'Package specific brand')
+        .action(withErrorHandling(async (options) => {
+        await packageCommand(getProjectRoot(), pickDefined(options));
+    }));
+}
+//# sourceMappingURL=package.js.map

package/dist/src/commands/re-export.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { ReExportOptions } from '../types/commands/index.js';
+/**
+ * Runs the re-export command to regenerate existing patches from current engine state.
+ * @param projectRoot - Root directory of the project
+ * @param patches - Patch identifiers (numbers or filenames)
+ * @param options - Re-export options
+ */
+export declare function reExportCommand(projectRoot: string, patches: string[], options: ReExportOptions): Promise<void>;
+/** Registers the re-export command on the CLI program. */
+export declare function registerReExport(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

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

@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { dirname, join } from 'node:path';
+import { multiselect } from '@clack/prompts';
+import { getProjectPaths, loadConfig } from '../core/config.js';
+import { isGitRepository } from '../core/git.js';
+import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
+import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
+import { updatePatch, updatePatchMetadata } from '../core/patch-export.js';
+import { lintExportedPatch } from '../core/patch-lint.js';
+import { getClaimedFiles, loadPatchesManifest } from '../core/patch-manifest.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
+import { pathExists } from '../utils/fs.js';
+import { cancel, info, intro, isCancel, outro, spinner, success, warn } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Resolves patch identifiers (numbers or filenames) to manifest entries.
+ * @param identifier - Patch number (e.g. "005") or filename (e.g. "005-ui-storage-modules.patch")
+ * @param patches - All patches from the manifest
+ * @returns Matching patch metadata
+ */
+function resolvePatchIdentifier(identifier, patches) {
+    // If all digits, match by order number
+    if (/^\d+$/.test(identifier)) {
+        const order = parseInt(identifier, 10);
+        return patches.find((p) => p.order === order) ?? null;
+    }
+    // Match by filename (with or without .patch suffix)
+    const normalized = identifier.endsWith('.patch') ? identifier : `${identifier}.patch`;
+    return patches.find((p) => p.filename === normalized) ?? null;
+}
+async function scanPatchFiles(currentFilesAffected, engineDir, manifest, patchFilename, isDryRun) {
+    const parentDirs = [...new Set(currentFilesAffected.map((f) => dirname(f)))];
+    const claimedByOthers = getClaimedFiles(manifest, patchFilename);
+    const discoveredFiles = new Set();
+    for (const dir of parentDirs) {
+        const modifiedFiles = await getModifiedFilesInDir(engineDir, dir);
+        const untrackedFiles = await getUntrackedFilesInDir(engineDir, dir);
+        for (const f of [...modifiedFiles, ...untrackedFiles]) {
+            discoveredFiles.add(f);
+        }
+    }
+    const currentSet = new Set(currentFilesAffected);
+    const added = [];
+    for (const f of discoveredFiles) {
+        if (!currentSet.has(f) && !claimedByOthers.has(f)) {
+            added.push(f);
+        }
+    }
+    const removed = [];
+    for (const f of currentFilesAffected) {
+        const filePath = join(engineDir, f);
+        if (!(await pathExists(filePath))) {
+            removed.push(f);
+        }
+    }
+    for (const f of added.sort()) {
+        info(`  + ${f}`);
+    }
+    for (const f of removed.sort()) {
+        info(`  - ${f}`);
+    }
+    if (added.length > 0 || removed.length > 0) {
+        const removedSet = new Set(removed);
+        const updated = [...currentFilesAffected.filter((f) => !removedSet.has(f)), ...added].sort();
+        info(`  ${isDryRun ? 'Would update' : 'Updated'} ${patchFilename}: +${added.length} / -${removed.length} files`);
+        return updated;
+    }
+    return currentFilesAffected;
+}
+async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, config) {
+    let currentFilesAffected = [...patch.filesAffected];
+    // --- Scan for new/removed files ---
+    if (options.scan) {
+        currentFilesAffected = await scanPatchFiles(currentFilesAffected, paths.engine, manifest, patch.filename, isDryRun);
+    }
+    const missingFiles = [];
+    for (const file of currentFilesAffected) {
+        const filePath = join(paths.engine, file);
+        if (!(await pathExists(filePath))) {
+            missingFiles.push(file);
+        }
+    }
+    if (missingFiles.length === currentFilesAffected.length) {
+        warn(`Skipped ${patch.filename}: all affected files missing`);
+        warn(`Missing files: ${missingFiles.join(', ')}`);
+        return false;
+    }
+    if (missingFiles.length > 0) {
+        warn(`${patch.filename}: missing files will be skipped: ${missingFiles.join(', ')}`);
+    }
+    const missingSet = new Set(missingFiles);
+    const existingFiles = currentFilesAffected.filter((f) => !missingSet.has(f));
+    const diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
+    if (!diffContent.trim()) {
+        warn(`Skipped ${patch.filename}: no changes (files unchanged from HEAD)`);
+        return false;
+    }
+    if (isDryRun) {
+        info(`[dry-run] ${patch.filename}: ${existingFiles.length} file(s)`);
+    }
+    else {
+        const patchPath = join(paths.patches, patch.filename);
+        await updatePatch(patchPath, diffContent);
+        await updatePatchMetadata(paths.patches, patch.filename, {
+            filesAffected: currentFilesAffected,
+        });
+        const patchIndex = manifest.patches.findIndex((pm) => pm.filename === patch.filename);
+        if (patchIndex !== -1) {
+            const existingEntry = manifest.patches[patchIndex];
+            if (existingEntry) {
+                manifest.patches[patchIndex] = {
+                    ...existingEntry,
+                    filesAffected: currentFilesAffected,
+                };
+            }
+        }
+        const lintIssues = await lintExportedPatch(paths.engine, existingFiles, diffContent, config);
+        for (const issue of lintIssues) {
+            const prefix = issue.severity === 'error' && !options.skipLint ? 'ERROR ' : '';
+            warn(`${prefix}[${issue.check}] ${issue.file}: ${issue.message}`);
+        }
+        const lintErrors = lintIssues.filter((i) => i.severity === 'error');
+        if (lintErrors.length > 0 && !options.skipLint) {
+            warn(`${patch.filename}: ${lintErrors.length} lint error(s). Use --skip-lint to bypass.`);
+        }
+        success(`Re-exported ${patch.filename}`);
+    }
+    return true;
+}
+async function resolveSelectedPatches(patches, options, manifest) {
+    if (options.all) {
+        return [...manifest.patches];
+    }
+    if (patches.length > 0) {
+        const selectedPatches = [];
+        for (const identifier of patches) {
+            const match = resolvePatchIdentifier(identifier, manifest.patches);
+            if (!match) {
+                const available = manifest.patches.map((p) => p.filename).join(', ');
+                throw new InvalidArgumentError(`Patch "${identifier}" not found in manifest.\n\nAvailable patches: ${available}`, identifier);
+            }
+            selectedPatches.push(match);
+        }
+        return selectedPatches;
+    }
+    // No patches specified — prompt or error
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    if (!isInteractive) {
+        throw new InvalidArgumentError('Specify patch identifiers or use --all in non-interactive mode.\n\n' +
+            'Usage: fireforge re-export [patches...] or fireforge re-export --all', 'patches');
+    }
+    const selected = await multiselect({
+        message: 'Select patches to re-export:',
+        options: manifest.patches.map((patch) => ({
+            value: patch.filename,
+            label: `${patch.filename} — ${patch.description || patch.name}`,
+        })),
+    });
+    if (isCancel(selected)) {
+        cancel('Re-export cancelled');
+        return null;
+    }
+    const selectedFilenames = selected;
+    return manifest.patches.filter((p) => selectedFilenames.includes(p.filename));
+}
+/**
+ * Runs the re-export command to regenerate existing patches from current engine state.
+ * @param projectRoot - Root directory of the project
+ * @param patches - Patch identifiers (numbers or filenames)
+ * @param options - Re-export options
+ */
+export async function reExportCommand(projectRoot, patches, options) {
+    const isDryRun = options.dryRun === true;
+    intro(isDryRun ? 'FireForge Re-export (dry run)' : 'FireForge Re-export');
+    const paths = getProjectPaths(projectRoot);
+    // Check if engine exists
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    // Check if it's a git repository
+    if (!(await isGitRepository(paths.engine))) {
+        throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
+    }
+    // Load the manifest
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest || manifest.patches.length === 0) {
+        throw new GeneralError('No patches found in manifest. Run "fireforge export" to create patches first.');
+    }
+    // Resolve which patches to re-export
+    const selectedPatches = await resolveSelectedPatches(patches, options, manifest);
+    if (!selectedPatches)
+        return;
+    if (selectedPatches.length === 0) {
+        warn('No patches selected');
+        outro('Nothing to re-export');
+        return;
+    }
+    const config = await loadConfig(projectRoot);
+    let reExported = 0;
+    const progress = spinner('Preparing re-export...');
+    for (const patch of selectedPatches) {
+        progress.message(`Re-exporting ${patch.filename}...`);
+        try {
+            const exported = await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config);
+            if (exported)
+                reExported++;
+        }
+        catch (error) {
+            warn(`Failed to re-export ${patch.filename}`);
+            warn(toError(error).message);
+        }
+    }
+    if (reExported === 0 && selectedPatches.length > 0) {
+        progress.error('Re-export failed');
+        throw new GeneralError('All selected patches failed to re-export. Check the errors above.');
+    }
+    if (isDryRun) {
+        progress.stop('Dry run complete');
+        success(`[dry-run] Would re-export ${reExported} of ${selectedPatches.length} patch(es)`);
+        outro('Dry run complete');
+    }
+    else {
+        progress.stop('Re-export complete');
+        success(`Re-exported ${reExported} of ${selectedPatches.length} patch(es)`);
+        outro('Re-export complete');
+    }
+}
+/** Registers the re-export command on the CLI program. */
+export function registerReExport(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('re-export [patches...]')
+        .description('Re-export existing patches from current engine state')
+        .option('-a, --all', 'Re-export all patches')
+        .option('-s, --scan', 'Scan directories for new/removed files and update filesAffected')
+        .option('--dry-run', 'Show what would change without writing')
+        .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
+        .action(withErrorHandling(async (patches, options) => {
+        await reExportCommand(getProjectRoot(), patches, pickDefined(options));
+    }));
+}
+//# sourceMappingURL=re-export.js.map

package/dist/src/commands/rebase/abort.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rebase abort flow.
+ */
+/**
+ * Handles `fireforge rebase --abort`.
+ */
+export declare function handleAbort(projectRoot: string, force?: boolean): Promise<void>;

package/dist/src/commands/rebase/abort.js

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Rebase abort flow.
+ */
+import { getProjectPaths, loadState, saveState } from '../../core/config.js';
+import { resetChanges } from '../../core/git.js';
+import { clearRebaseSession, loadRebaseSession } from '../../core/rebase-session.js';
+import { NoRebaseSessionError } from '../../errors/rebase.js';
+import { intro, outro, spinner, success } from '../../utils/logger.js';
+import { confirmDirtyEngineReset } from './confirm.js';
+/**
+ * Handles `fireforge rebase --abort`.
+ */
+export async function handleAbort(projectRoot, force) {
+    intro('FireForge Rebase — Abort');
+    const session = await loadRebaseSession(projectRoot);
+    if (!session)
+        throw new NoRebaseSessionError();
+    const paths = getProjectPaths(projectRoot);
+    if (!(await confirmDirtyEngineReset({
+        engineDir: paths.engine,
+        force: force ?? false,
+        nonInteractiveHint: 'Use: fireforge rebase --abort --force',
+        warningMessage: 'The engine directory has uncommitted changes that will be lost.',
+        promptMessage: 'Discard uncommitted changes and abort rebase?',
+        cancelMessage: 'Abort cancelled',
+    }))) {
+        return;
+    }
+    const s = spinner('Restoring engine to pre-rebase state...');
+    try {
+        await resetChanges(paths.engine);
+        s.stop('Engine restored');
+    }
+    catch (error) {
+        s.error('Failed to restore engine');
+        throw error;
+    }
+    // Clear pending resolution state if any
+    const state = await loadState(projectRoot);
+    if (state.pendingResolution) {
+        delete state.pendingResolution;
+        await saveState(projectRoot, state);
+    }
+    await clearRebaseSession(projectRoot);
+    success('Rebase aborted and session cleared.');
+    outro('Rebase aborted');
+}
+//# sourceMappingURL=abort.js.map

package/dist/src/commands/rebase/confirm.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dirty-engine confirmation/reset flow.
+ */
+/** Options for the dirty-engine confirmation prompt. */
+export interface DirtyEngineConfirmationOptions {
+    engineDir: string;
+    force: boolean;
+    nonInteractiveHint: string;
+    warningMessage: string;
+    promptMessage: string;
+    cancelMessage: string;
+}
+/**
+ * Checks if the engine has uncommitted changes and prompts for confirmation.
+ * Returns true if safe to proceed, false if the user cancelled.
+ * Throws in non-interactive mode without --force.
+ */
+export declare function confirmDirtyEngineReset({ engineDir, force, nonInteractiveHint, warningMessage, promptMessage, cancelMessage, }: DirtyEngineConfirmationOptions): Promise<boolean>;

package/dist/src/commands/rebase/confirm.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Dirty-engine confirmation/reset flow.
+ */
+import { confirm } from '@clack/prompts';
+import { hasChanges } from '../../core/git.js';
+import { InvalidArgumentError } from '../../errors/base.js';
+import { cancel, isCancel, warn } from '../../utils/logger.js';
+/**
+ * Checks if the engine has uncommitted changes and prompts for confirmation.
+ * Returns true if safe to proceed, false if the user cancelled.
+ * Throws in non-interactive mode without --force.
+ */
+export async function confirmDirtyEngineReset({ engineDir, force, nonInteractiveHint, warningMessage, promptMessage, cancelMessage, }) {
+    if (!(await hasChanges(engineDir)) || force) {
+        return true;
+    }
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    if (!isInteractive) {
+        throw new InvalidArgumentError('Engine has uncommitted changes and interactive confirmation is not available. Use --force to proceed.', nonInteractiveHint);
+    }
+    warn(warningMessage);
+    const confirmed = await confirm({
+        message: promptMessage,
+        initialValue: false,
+    });
+    if (isCancel(confirmed) || !confirmed) {
+        cancel(cancelMessage);
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=confirm.js.map

package/dist/src/commands/rebase/continue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rebase --continue flow.
+ */
+/**
+ * Handles `fireforge rebase --continue`.
+ */
+export declare function handleContinue(projectRoot: string, maxFuzz: number): Promise<void>;

package/dist/src/commands/rebase/continue.js

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Rebase --continue flow.
+ */
+import { join } from 'node:path';
+import { getProjectPaths, loadState, saveState } from '../../core/config.js';
+import { getStagedDiffForFiles } from '../../core/git-diff.js';
+import { stageFiles, unstageFiles } from '../../core/git-file-ops.js';
+import { updatePatch, updatePatchMetadata } from '../../core/patch-export.js';
+import { loadPatchesManifest } from '../../core/patch-manifest.js';
+import { loadRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
+import { GeneralError } from '../../errors/base.js';
+import { NoRebaseSessionError, RebaseError } from '../../errors/rebase.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, success, warn } from '../../utils/logger.js';
+import { runPatchLoop } from './patch-loop.js';
+/**
+ * Handles `fireforge rebase --continue`.
+ */
+export async function handleContinue(projectRoot, maxFuzz) {
+    intro('FireForge Rebase — Continue');
+    const session = await loadRebaseSession(projectRoot);
+    if (!session)
+        throw new NoRebaseSessionError();
+    const paths = getProjectPaths(projectRoot);
+    // The current patch should be in 'failed' state
+    const currentPatch = session.patches[session.currentIndex];
+    if (!currentPatch || currentPatch.status !== 'failed') {
+        throw new RebaseError('Expected the current patch to be in a failed state. The session may be corrupt.');
+    }
+    info(`Resolving: ${currentPatch.filename}`);
+    // Look up the patch's files from the manifest
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest)
+        throw new GeneralError('Patches manifest not found.');
+    const meta = manifest.patches.find((p) => p.filename === currentPatch.filename);
+    if (!meta)
+        throw new GeneralError(`Patch ${currentPatch.filename} not found in manifest.`);
+    // Re-export the resolved patch from current engine state
+    const activeFiles = [];
+    for (const f of meta.filesAffected) {
+        if (await pathExists(join(paths.engine, f))) {
+            activeFiles.push(f);
+        }
+    }
+    let staged = false;
+    try {
+        await stageFiles(paths.engine, activeFiles);
+        staged = true;
+        const diffContent = await getStagedDiffForFiles(paths.engine, activeFiles);
+        if (!diffContent.trim()) {
+            warn('No diff generated — the files may not have changed from HEAD.');
+            warn('Either apply your fixes and re-run --continue, or skip this patch (not yet supported).');
+            return;
+        }
+        const patchPath = join(paths.patches, currentPatch.filename);
+        await updatePatch(patchPath, diffContent);
+        await updatePatchMetadata(paths.patches, currentPatch.filename, {
+            sourceEsrVersion: session.toVersion,
+        });
+    }
+    finally {
+        if (staged) {
+            await unstageFiles(paths.engine, activeFiles);
+        }
+    }
+    // Mark resolved and advance
+    currentPatch.status = 'resolved';
+    session.currentIndex++;
+    await saveRebaseSession(projectRoot, session);
+    // Clear pending resolution
+    const state = await loadState(projectRoot);
+    if (state.pendingResolution) {
+        delete state.pendingResolution;
+        await saveState(projectRoot, state);
+    }
+    success(`Resolved ${currentPatch.filename}`);
+    // Continue applying remaining patches
+    await runPatchLoop(projectRoot, session, paths, maxFuzz);
+}
+//# sourceMappingURL=continue.js.map

package/dist/src/commands/rebase/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `fireforge rebase` — semi-automated ESR version upgrade.
+ *
+ * Orchestrates the full patch-rebase workflow:
+ *   1. Reset engine to baseline
+ *   2. Apply each patch with escalating fuzz
+ *   3. Pause on failures for manual resolution
+ *   4. Re-export successfully applied patches with the new version stamp
+ *
+ * Supports `--continue` (resume after manual fix) and `--abort` (cancel).
+ */
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import type { RebaseOptions } from '../../types/commands/index.js';
+/**
+ * Runs the rebase command to orchestrate an ESR version upgrade.
+ * @param projectRoot - Root directory of the project
+ * @param options - Rebase options
+ */
+export declare function rebaseCommand(projectRoot: string, options?: RebaseOptions): Promise<void>;
+/** Registers the rebase command on the CLI program. */
+export declare function registerRebase(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;