@hominis/fireforge 0.9.0

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

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `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 { getProjectPaths, loadConfig } from '../../core/config.js';
+import { getHead, isGitRepository, resetChanges } from '../../core/git.js';
+import { discoverPatches } from '../../core/patch-files.js';
+import { loadPatchesManifest } from '../../core/patch-manifest.js';
+import { hasActiveRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
+import { GeneralError } from '../../errors/base.js';
+import { RebaseSessionExistsError } from '../../errors/rebase.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, outro, spinner } from '../../utils/logger.js';
+import { pickDefined } from '../../utils/options.js';
+import { handleAbort } from './abort.js';
+import { confirmDirtyEngineReset } from './confirm.js';
+import { handleContinue } from './continue.js';
+import { runPatchLoop } from './patch-loop.js';
+// ── Fresh start ──
+async function handleFreshStart(projectRoot, options) {
+    const isDryRun = options.dryRun === true;
+    const maxFuzz = options.maxFuzz ?? 3;
+    intro(isDryRun ? 'FireForge Rebase (dry run)' : 'FireForge Rebase');
+    if (await hasActiveRebaseSession(projectRoot)) {
+        throw new RebaseSessionExistsError();
+    }
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    if (!(await isGitRepository(paths.engine))) {
+        throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
+    }
+    const config = await loadConfig(projectRoot);
+    const currentVersion = config.firefox.version;
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest || manifest.patches.length === 0) {
+        throw new GeneralError('No patches found in manifest. Nothing to rebase.');
+    }
+    // Determine the "from" version from the patches
+    const patchVersions = new Set(manifest.patches.map((p) => p.sourceEsrVersion));
+    const sortedVersions = [...patchVersions].sort();
+    const fromVersion = sortedVersions[0] ?? currentVersion;
+    if (patchVersions.size === 1 && fromVersion === currentVersion) {
+        info('All patches already match the current Firefox version. Nothing to rebase.');
+        outro('Rebase not needed');
+        return;
+    }
+    info(`Rebasing patches: ${fromVersion} → ${currentVersion}`);
+    info(`Found ${manifest.patches.length} patch(es)`);
+    info(`Max fuzz factor: ${maxFuzz}`);
+    if (isDryRun) {
+        info('[dry-run] Would reset engine, apply patches with fuzz, and re-export.');
+        outro('Dry run complete');
+        return;
+    }
+    if (!(await confirmDirtyEngineReset({
+        engineDir: paths.engine,
+        force: options.force ?? false,
+        nonInteractiveHint: 'Use: fireforge rebase --force',
+        warningMessage: 'The engine directory has uncommitted changes that will be lost by the rebase.',
+        promptMessage: 'Discard uncommitted changes and start rebase?',
+        cancelMessage: 'Rebase cancelled',
+    }))) {
+        return;
+    }
+    // Record pre-rebase commit for --abort
+    const preRebaseCommit = await getHead(paths.engine);
+    // Reset engine to baseline
+    const resetSpinner = spinner('Resetting engine to baseline...');
+    await resetChanges(paths.engine);
+    resetSpinner.stop('Engine reset to baseline');
+    // Create rebase session
+    const allPatches = await discoverPatches(paths.patches);
+    const session = {
+        startedAt: new Date().toISOString(),
+        fromVersion,
+        toVersion: currentVersion,
+        preRebaseCommit,
+        patches: allPatches.map((p) => ({
+            filename: p.filename,
+            status: 'pending',
+        })),
+        currentIndex: 0,
+    };
+    await saveRebaseSession(projectRoot, session);
+    // Run the patch loop
+    await runPatchLoop(projectRoot, session, paths, maxFuzz);
+}
+// ── Public API ──
+/**
+ * Runs the rebase command to orchestrate an ESR version upgrade.
+ * @param projectRoot - Root directory of the project
+ * @param options - Rebase options
+ */
+export async function rebaseCommand(projectRoot, options = {}) {
+    if (options.abort) {
+        return handleAbort(projectRoot, options.force);
+    }
+    if (options.continue) {
+        return handleContinue(projectRoot, options.maxFuzz ?? 3);
+    }
+    return handleFreshStart(projectRoot, options);
+}
+/** Registers the rebase command on the CLI program. */
+export function registerRebase(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('rebase')
+        .description('Semi-automated ESR version upgrade — apply patches with fuzz and re-export')
+        .option('--continue', 'Resume after manually resolving a failed patch')
+        .option('--abort', 'Cancel the rebase and restore engine to pre-rebase state')
+        .option('--dry-run', 'Show what would happen without modifying anything')
+        .option('--max-fuzz <n>', 'Maximum fuzz factor for git apply (default: 3)', parseInt)
+        .option('-f, --force', 'Skip dirty-tree confirmation prompt')
+        .action(withErrorHandling(async (options) => {
+        await rebaseCommand(getProjectRoot(), pickDefined(options));
+    }));
+}
+//# sourceMappingURL=index.js.map

package/dist/src/commands/rebase/patch-loop.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Patch application loop and re-export flow.
+ */
+import type { getProjectPaths } from '../../core/config.js';
+import type { RebaseSession } from '../../core/rebase-session.js';
+/**
+ * Runs the patch application loop, re-exports applied patches, and stamps versions.
+ */
+export declare function runPatchLoop(projectRoot: string, session: RebaseSession, paths: ReturnType<typeof getProjectPaths>, maxFuzz: number): Promise<void>;

package/dist/src/commands/rebase/patch-loop.js

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch application loop and re-export flow.
+ */
+import { join } from 'node:path';
+import { loadState, saveState } from '../../core/config.js';
+import { getDiffForFilesAgainstHead } from '../../core/git-diff.js';
+import { applyPatchWithFuzz } from '../../core/patch-apply-fuzz.js';
+import { updatePatch } from '../../core/patch-export.js';
+import { discoverPatches } from '../../core/patch-files.js';
+import { loadPatchesManifest, stampPatchVersions } from '../../core/patch-manifest.js';
+import { extractConflictingFiles } from '../../core/patch-parse.js';
+import { clearRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
+import { toError } from '../../utils/errors.js';
+import { pathExists } from '../../utils/fs.js';
+import { error, info, outro, spinner, success, warn } from '../../utils/logger.js';
+import { printSummary } from './summary.js';
+/**
+ * Runs the patch application loop, re-exports applied patches, and stamps versions.
+ */
+export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
+    const allPatches = await discoverPatches(paths.patches);
+    const s = spinner('Applying patches...');
+    for (let i = session.currentIndex; i < session.patches.length; i++) {
+        const entry = session.patches[i];
+        if (!entry)
+            continue;
+        const patchFile = allPatches.find((p) => p.filename === entry.filename);
+        if (!patchFile) {
+            warn(`Patch file not found for ${entry.filename}, skipping.`);
+            entry.status = 'skipped';
+            session.currentIndex = i + 1;
+            await saveRebaseSession(projectRoot, session);
+            continue;
+        }
+        s.message(`Applying ${entry.filename}...`);
+        const result = await applyPatchWithFuzz(patchFile.path, paths.engine, maxFuzz);
+        if (result.success) {
+            if (result.fuzzFactor === 0) {
+                entry.status = 'applied-clean';
+                success(`  ${entry.filename} — applied cleanly`);
+            }
+            else {
+                entry.status = 'applied-fuzz';
+                entry.fuzzFactor = result.fuzzFactor;
+                warn(`  ${entry.filename} — applied with fuzz=${result.fuzzFactor}`);
+            }
+            session.currentIndex = i + 1;
+            await saveRebaseSession(projectRoot, session);
+        }
+        else {
+            entry.status = 'failed';
+            if (result.error) {
+                entry.error = result.error;
+            }
+            entry.conflictingFiles = extractConflictingFiles(result.error);
+            session.currentIndex = i;
+            await saveRebaseSession(projectRoot, session);
+            // Set pendingResolution in state for visibility
+            const state = await loadState(projectRoot);
+            state.pendingResolution = {
+                patchFilename: entry.filename,
+                originalError: result.error ?? 'Unknown error',
+            };
+            await saveState(projectRoot, state);
+            s.error(`${entry.filename} failed to apply`);
+            if (result.error) {
+                error(`  Error: ${result.error}`);
+            }
+            if (result.rejectFiles && result.rejectFiles.length > 0) {
+                info(`  .rej files created for manual resolution`);
+            }
+            info('');
+            info('Resolution instructions:');
+            info('  1. Manually fix the conflicts in engine/ (look for .rej files)');
+            info('  2. Run "fireforge rebase --continue" to resume');
+            info('  3. Or run "fireforge rebase --abort" to cancel the rebase');
+            return; // Stop the loop
+        }
+    }
+    s.stop('All patches applied');
+    // Re-export all successfully applied patches
+    await reExportAppliedPatches(session, paths);
+    // Stamp versions
+    const appliedFilenames = session.patches
+        .filter((p) => p.status === 'applied-clean' || p.status === 'applied-fuzz' || p.status === 'resolved')
+        .map((p) => p.filename);
+    if (appliedFilenames.length > 0) {
+        await stampPatchVersions(paths.patches, appliedFilenames, session.toVersion);
+    }
+    // Print summary and clean up
+    printSummary(session);
+    await clearRebaseSession(projectRoot);
+    // Clear pending resolution if any
+    const state = await loadState(projectRoot);
+    if (state.pendingResolution) {
+        delete state.pendingResolution;
+        await saveState(projectRoot, state);
+    }
+    info('');
+    success(`All patches re-exported with sourceEsrVersion=${session.toVersion}`);
+    outro('Rebase complete!');
+}
+async function reExportAppliedPatches(session, paths) {
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest)
+        return;
+    const s = spinner('Re-exporting patches...');
+    for (const entry of session.patches) {
+        if (entry.status !== 'applied-clean' && entry.status !== 'applied-fuzz')
+            continue;
+        const meta = manifest.patches.find((p) => p.filename === entry.filename);
+        if (!meta)
+            continue;
+        s.message(`Re-exporting ${entry.filename}...`);
+        const existingFiles = [];
+        for (const f of meta.filesAffected) {
+            if (await pathExists(join(paths.engine, f))) {
+                existingFiles.push(f);
+            }
+        }
+        try {
+            const diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
+            if (diffContent.trim()) {
+                const patchPath = join(paths.patches, entry.filename);
+                await updatePatch(patchPath, diffContent);
+            }
+        }
+        catch (err) {
+            warn(`Failed to re-export ${entry.filename}: ${toError(err).message}`);
+        }
+    }
+    s.stop('Patches re-exported');
+}
+//# sourceMappingURL=patch-loop.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * Rebase summary and status label formatting.
+ */
+import type { RebasePatchEntry, RebaseSession } from '../../core/rebase-session.js';
+/**
+ * Formats a status label for a rebase patch entry.
+ */
+export declare function statusLabel(status: RebasePatchEntry['status'], fuzzFactor?: number): string;
+/**
+ * Prints the rebase summary table.
+ */
+export declare function printSummary(session: RebaseSession): void;

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

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Rebase summary and status label formatting.
+ */
+import { info } from '../../utils/logger.js';
+/**
+ * Formats a status label for a rebase patch entry.
+ */
+export function statusLabel(status, fuzzFactor) {
+    switch (status) {
+        case 'applied-clean':
+            return 'applied cleanly';
+        case 'applied-fuzz':
+            return `applied with fuzz=${fuzzFactor ?? '?'}`;
+        case 'resolved':
+            return 'RESOLVED manually';
+        case 'failed':
+            return 'FAILED';
+        case 'skipped':
+            return 'skipped';
+        case 'pending':
+            return 'pending';
+    }
+}
+/**
+ * Prints the rebase summary table.
+ */
+export function printSummary(session) {
+    info('');
+    info(`ESR Rebase Summary: ${session.fromVersion} → ${session.toVersion}`);
+    info('='.repeat(55));
+    for (const patch of session.patches) {
+        const label = statusLabel(patch.status, patch.fuzzFactor);
+        info(`  ${patch.filename} ${'·'.repeat(Math.max(1, 45 - patch.filename.length - label.length))} ${label}`);
+    }
+    const clean = session.patches.filter((p) => p.status === 'applied-clean').length;
+    const fuzz = session.patches.filter((p) => p.status === 'applied-fuzz').length;
+    const resolved = session.patches.filter((p) => p.status === 'resolved').length;
+    const failed = session.patches.filter((p) => p.status === 'failed').length;
+    info('');
+    info(`Results: ${clean} clean, ${fuzz} fuzz-applied, ${resolved} manually resolved, ${failed} failed`);
+}
+//# sourceMappingURL=summary.js.map

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

@@ -0,0 +1,4 @@
+/**
+ * `fireforge rebase` — re-exports from `./rebase/` sub-modules.
+ */
+export { rebaseCommand, registerRebase } from './rebase/index.js';

package/dist/src/commands/rebase.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `fireforge rebase` — re-exports from `./rebase/` sub-modules.
+ */
+export { rebaseCommand, registerRebase } from './rebase/index.js';
+//# sourceMappingURL=rebase.js.map

package/dist/src/commands/register.d.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { RegisterOptions } from '../types/commands/index.js';
+/**
+ * Registers a file in the appropriate build manifest.
+ *
+ * @param projectRoot - Root directory of the project
+ * @param filePath - Path relative to engine/
+ * @param options - Command options
+ */
+export declare function registerCommand(projectRoot: string, filePath: string, options?: RegisterOptions): Promise<void>;
+/** Registers the browser content registration command on the CLI program. */
+export declare function registerRegister(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/register.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { getProjectPaths } from '../core/config.js';
+import { registerFile } from '../core/manifest-rules.js';
+import { InvalidArgumentError } from '../errors/base.js';
+import { pathExists } from '../utils/fs.js';
+import { info, intro, outro, success, warn } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Registers a file in the appropriate build manifest.
+ *
+ * @param projectRoot - Root directory of the project
+ * @param filePath - Path relative to engine/
+ * @param options - Command options
+ */
+export async function registerCommand(projectRoot, filePath, options = {}) {
+    intro('Register');
+    // Verify the file exists in engine/ (skip for dry-run)
+    if (!options.dryRun) {
+        const paths = getProjectPaths(projectRoot);
+        const fullPath = join(paths.engine, filePath);
+        if (!(await pathExists(fullPath))) {
+            throw new InvalidArgumentError(`File not found in engine: ${filePath}`, 'path');
+        }
+    }
+    const result = await registerFile(projectRoot, filePath, options.dryRun, options.after);
+    if (options.dryRun) {
+        info(`[dry-run] Would register ${filePath}`);
+        info(`  manifest: ${result.manifest}`);
+        info(`  entry: ${result.entry}`);
+        if (result.previousEntry) {
+            info(`  insert after: ${result.previousEntry}`);
+        }
+        else {
+            info('  insert at: start of matching section');
+        }
+        if (result.afterFallback) {
+            warn(`--after target "${options.after}" not found, falling back to alphabetical order`);
+        }
+        outro('Dry run complete');
+        return;
+    }
+    if (result.skipped) {
+        info(`Already registered: ${filePath} in ${result.manifest}`);
+    }
+    else {
+        if (result.afterFallback) {
+            warn(`--after target "${options.after}" not found, falling back to alphabetical order`);
+        }
+        const position = result.previousEntry ? ` (after ${result.previousEntry})` : '';
+        success(`Registered ${filePath} in ${result.manifest}${position}`);
+        info("hint: Run 'fireforge build --ui' to make the new module available at runtime");
+    }
+    outro('Done');
+}
+/** Registers the browser content registration command on the CLI program. */
+export function registerRegister(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('register <path>')
+        .description('Register a file in the appropriate build manifest')
+        .option('--dry-run', 'Show what would be changed without writing')
+        .option('--after <entry>', 'Place entry after line containing this substring (instead of alphabetical)')
+        .action(withErrorHandling(async (path, options) => {
+        await registerCommand(getProjectRoot(), path, pickDefined(options));
+    }));
+}
+//# sourceMappingURL=register.js.map

package/dist/src/commands/reset.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { ResetOptions } from '../types/commands/index.js';
+/**
+ * Runs the reset command to restore clean Firefox state.
+ * @param projectRoot - Root directory of the project
+ * @param options - Reset options
+ */
+export declare function resetCommand(projectRoot: string, options: ResetOptions): Promise<void>;
+/** Registers the reset command on the CLI program. */
+export declare function registerReset(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/reset.js

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { confirm } from '@clack/prompts';
+import { getProjectPaths } from '../core/config.js';
+import { hasChanges, isGitRepository, resetChanges } from '../core/git.js';
+import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { pathExists } from '../utils/fs.js';
+import { cancel, info, intro, isCancel, outro, spinner, warn } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Runs the reset command to restore clean Firefox state.
+ * @param projectRoot - Root directory of the project
+ * @param options - Reset options
+ */
+export async function resetCommand(projectRoot, options) {
+    intro('FireForge Reset');
+    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.');
+    }
+    // Check for changes
+    const hasUncommittedChanges = await hasChanges(paths.engine);
+    if (!hasUncommittedChanges) {
+        info('No changes to reset');
+        outro('Working tree already clean');
+        return;
+    }
+    // Dry-run: show what would be reset
+    if (options.dryRun) {
+        const statusEntries = await expandUntrackedDirectoryEntries(paths.engine, await getWorkingTreeStatus(paths.engine));
+        info(`Would reset ${statusEntries.length} file${statusEntries.length === 1 ? '' : 's'}:`);
+        for (const entry of statusEntries) {
+            const label = entry.originalPath ? `${entry.originalPath} -> ${entry.file}` : entry.file;
+            info(`  ${label}`);
+        }
+        outro('Dry run complete — no changes made');
+        return;
+    }
+    // Confirm reset unless --force is specified
+    if (!options.force) {
+        // Check for non-interactive mode
+        const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+        if (!isInteractive) {
+            throw new InvalidArgumentError('Interactive confirmation not available. Use --force flag to reset without confirmation.', 'Use: fireforge reset --force');
+        }
+        warn('This will discard all uncommitted changes in the engine directory, including staged additions and untracked files.');
+        const confirmed = await confirm({
+            message: 'Are you sure you want to reset?',
+            initialValue: false,
+        });
+        if (isCancel(confirmed) || !confirmed) {
+            cancel('Reset cancelled');
+            return;
+        }
+    }
+    const s = spinner('Resetting changes...');
+    try {
+        await resetChanges(paths.engine);
+        s.stop('Changes reset');
+        outro('Working tree restored to clean state');
+    }
+    catch (error) {
+        s.error('Reset failed');
+        throw error;
+    }
+}
+/** Registers the reset command on the CLI program. */
+export function registerReset(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('reset')
+        .description('Reset engine/ to clean state')
+        .option('-f, --force', 'Skip confirmation prompt (required for scripts/CI)')
+        .option('--dry-run', 'Show what would be reset without doing it')
+        .action(withErrorHandling(async (options) => {
+        await resetCommand(getProjectRoot(), pickDefined(options));
+    }));
+}
+//# sourceMappingURL=reset.js.map

package/dist/src/commands/resolve.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+/**
+ * Runs the resolve command to fix broken patches.
+ * @param projectRoot - Root directory of the project
+ */
+export declare function resolveCommand(projectRoot: string): Promise<void>;
+/** Registers the resolve command on the CLI program. */
+export declare function registerResolve(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/resolve.js

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { confirm } from '@clack/prompts';
+import { getProjectPaths, loadConfig, loadState, saveState } from '../core/config.js';
+import { isGitRepository } from '../core/git.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 { GeneralError, ResolutionError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
+import { pathExists } from '../utils/fs.js';
+import { error as logError, info, intro, isCancel, outro, spinner, success, } from '../utils/logger.js';
+/**
+ * Runs the resolve command to fix broken patches.
+ * @param projectRoot - Root directory of the project
+ */
+export async function resolveCommand(projectRoot) {
+    intro('FireForge Resolve');
+    const paths = getProjectPaths(projectRoot);
+    const state = await loadState(projectRoot);
+    if (!state.pendingResolution) {
+        info('No patch resolution currently required.');
+        outro('Resolution complete');
+        return;
+    }
+    const { patchFilename } = state.pendingResolution;
+    info(`Resolving conflict for patch: ${patchFilename}`);
+    // 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.');
+    }
+    if (!process.stdin.isTTY) {
+        throw new GeneralError('Cannot run "fireforge resolve" in non-interactive mode. Use a terminal with TTY support.');
+    }
+    const finished = await confirm({
+        message: 'Have you finished manually fixing the files in engine/?',
+        initialValue: true,
+    });
+    if (isCancel(finished) || !finished) {
+        info('Please fix the conflicts and run "fireforge resolve" again.');
+        outro('Resolution paused');
+        return;
+    }
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest) {
+        throw new GeneralError('Patches manifest not found.');
+    }
+    const patchMetadata = manifest.patches.find((p) => p.filename === patchFilename);
+    if (!patchMetadata) {
+        throw new ResolutionError(`Patch ${patchFilename} not found in manifest.`);
+    }
+    const s = spinner(`Updating ${patchFilename}...`);
+    try {
+        const existingFiles = patchMetadata.filesAffected;
+        // Verify all affected files exist in engine/
+        const missingFiles = [];
+        for (const file of existingFiles) {
+            const filePath = join(paths.engine, file);
+            if (!(await pathExists(filePath))) {
+                missingFiles.push(file);
+            }
+        }
+        if (missingFiles.length === existingFiles.length) {
+            throw new ResolutionError(`All affected files for ${patchFilename} are missing.`);
+        }
+        // Filter to only existing files
+        const activeFiles = existingFiles.filter((f) => !missingFiles.includes(f));
+        // Stage, diff, unstage
+        let diffContent;
+        let staged = false;
+        try {
+            await stageFiles(paths.engine, activeFiles);
+            staged = true;
+            diffContent = await getStagedDiffForFiles(paths.engine, activeFiles);
+        }
+        finally {
+            if (staged) {
+                await unstageFiles(paths.engine, activeFiles);
+            }
+        }
+        if (!diffContent.trim()) {
+            s.stop(`No patch update generated for ${patchFilename}`);
+            info('No patch update was generated from the staged diff. Pending resolution was left intact so you can retry. To discard the resolution state, delete the "pendingResolution" key from state.json.');
+            outro('Resolution unchanged');
+            return;
+        }
+        // Write the new diff content to the patch file
+        const patchPath = join(paths.patches, patchFilename);
+        await updatePatch(patchPath, diffContent);
+        // Update metadata (preserve original createdAt)
+        const config = await loadConfig(projectRoot);
+        await updatePatchMetadata(paths.patches, patchFilename, {
+            ...(activeFiles.length < existingFiles.length ? { filesAffected: activeFiles } : {}),
+            sourceEsrVersion: config.firefox.version,
+        });
+        // Cleanup: Clear pendingResolution from state.json
+        delete state.pendingResolution;
+        await saveState(projectRoot, state);
+        s.stop(`Updated ${patchFilename}`);
+        success('Patch updated successfully and resolution state cleared.');
+        info('Run "fireforge import" to apply the remaining patches.');
+        outro('Resolution complete');
+    }
+    catch (error) {
+        s.error(`Resolution failed for ${patchFilename}`);
+        logError(toError(error).message);
+        throw error;
+    }
+}
+/** Registers the resolve command on the CLI program. */
+export function registerResolve(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('resolve')
+        .description('Update a broken patch with manual fixes and continue')
+        .action(withErrorHandling(async () => {
+        await resolveCommand(getProjectRoot());
+    }));
+}
+//# sourceMappingURL=resolve.js.map

package/dist/src/commands/run.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+/**
+ * Runs the run command to launch the built browser.
+ * @param projectRoot - Root directory of the project
+ */
+export declare function runCommand(projectRoot: string): Promise<void>;
+/** Registers the run command on the CLI program. */
+export declare function registerRun(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;