@hominis/fireforge 0.9.0

package/dist/src/commands/furnace/deploy.js

@@ -0,0 +1,338 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { getProjectPaths } from '../../core/config.js';
+import { applyAllComponents, applyCustomComponent, applyOverrideComponent, computeComponentChecksums, prefixChecksums, } from '../../core/furnace-apply.js';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, updateFurnaceState, } from '../../core/furnace-config.js';
+import { createRollbackJournal, restoreRollbackJournalOrThrow, } from '../../core/furnace-rollback.js';
+import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { toError } from '../../utils/errors.js';
+import { pathExists } from '../../utils/fs.js';
+import { error, info, intro, note, outro, spinner, success, warn } from '../../utils/logger.js';
+import { displayValidationIssues } from './validation-output.js';
+/**
+ * Builds the final deploy failure summary from apply and validation error counts.
+ * @param applyErrors - Number of component application failures
+ * @param validationErrors - Number of validation failures
+ * @param isDryRun - Whether deploy was running in dry-run mode
+ * @returns User-facing deploy summary message
+ */
+function buildDeployFailureMessage(applyErrors, validationErrors, isDryRun) {
+    const mode = isDryRun ? 'Dry run' : 'Deploy';
+    if (applyErrors > 0 && validationErrors > 0) {
+        return `${mode} completed with ${applyErrors} apply error(s) and ${validationErrors} validation error(s).`;
+    }
+    if (applyErrors > 0) {
+        return `${mode} completed with ${applyErrors} apply error(s).`;
+    }
+    return `${mode} completed with ${validationErrors} validation error(s).`;
+}
+function getStepFailureCount(result) {
+    return result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+}
+function getFailedComponentNames(result) {
+    const failed = new Set(result.errors.map((entry) => entry.name));
+    for (const applied of result.applied) {
+        if ((applied.stepErrors?.length ?? 0) > 0) {
+            failed.add(applied.name);
+        }
+    }
+    return failed;
+}
+/**
+ * Persists checksum state for a successfully applied named component.
+ * @param projectRoot - Root directory of the project
+ * @param appliedEntry - Applied component descriptor from deploy
+ * @param furnacePaths - Resolved Furnace workspace paths
+ */
+async function persistSingleComponentState(projectRoot, appliedEntry, furnacePaths) {
+    const componentDir = appliedEntry.type === 'override'
+        ? join(furnacePaths.overridesDir, appliedEntry.name)
+        : join(furnacePaths.customDir, appliedEntry.name);
+    const checksums = await computeComponentChecksums(componentDir);
+    const prefixed = prefixChecksums(checksums, appliedEntry.type, appliedEntry.name);
+    await updateFurnaceState(projectRoot, (current) => ({
+        ...current,
+        appliedChecksums: { ...(current.appliedChecksums ?? {}), ...prefixed },
+        lastApply: new Date().toISOString(),
+    }));
+}
+/**
+ * Applies a single named override or custom component in targeted deploy mode.
+ * @param name - Component name to apply
+ * @param engineDir - Firefox engine source directory
+ * @param furnacePaths - Resolved Furnace workspace paths
+ * @param config - Loaded Furnace configuration
+ * @param isDryRun - Whether file writes should be skipped
+ * @returns Apply result for the named component, or `stock` for stock-only entries
+ */
+async function applyNamedComponent(name, engineDir, furnacePaths, config, isDryRun) {
+    const rollbackJournal = isDryRun ? undefined : createRollbackJournal();
+    const result = {
+        applied: [],
+        skipped: [],
+        errors: [],
+        actions: [],
+    };
+    const overrideConfig = config.overrides[name];
+    const customConfig = config.custom[name];
+    if (overrideConfig) {
+        const componentDir = join(furnacePaths.overridesDir, name);
+        if (!(await pathExists(componentDir))) {
+            throw new FurnaceError(`Component directory not found: components/overrides/${name}`, name);
+        }
+        try {
+            const { affectedPaths: filesAffected, actions } = await applyOverrideComponent(engineDir, name, componentDir, overrideConfig, isDryRun, rollbackJournal);
+            if (isDryRun && actions) {
+                result.actions = actions;
+            }
+            result.applied.push({ name, type: 'override', filesAffected });
+        }
+        catch (error) {
+            result.errors.push({ name, error: toError(error).message });
+        }
+        if (!isDryRun && result.errors.length > 0 && rollbackJournal) {
+            await restoreRollbackJournalOrThrow(rollbackJournal, `Furnace deploy failed for "${name}"`);
+        }
+        return result;
+    }
+    if (customConfig) {
+        const componentDir = join(furnacePaths.customDir, name);
+        if (!(await pathExists(componentDir))) {
+            throw new FurnaceError(`Component directory not found: components/custom/${name}`, name);
+        }
+        try {
+            const { affectedPaths: filesAffected, stepErrors, actions, } = await applyCustomComponent(engineDir, name, componentDir, customConfig, isDryRun, rollbackJournal);
+            if (isDryRun && actions) {
+                result.actions = actions;
+            }
+            result.applied.push({
+                name,
+                type: 'custom',
+                filesAffected,
+                ...(stepErrors.length > 0 ? { stepErrors } : {}),
+            });
+        }
+        catch (error) {
+            result.errors.push({ name, error: toError(error).message });
+        }
+        if (!isDryRun && getStepFailureCount(result) > 0 && rollbackJournal) {
+            await restoreRollbackJournalOrThrow(rollbackJournal, `Furnace deploy failed for "${name}"`);
+        }
+        return result;
+    }
+    if (config.stock.includes(name)) {
+        return 'stock';
+    }
+    throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
+}
+/**
+ * Resolves the validation target for a single named component.
+ * @param name - Component name to validate
+ * @param config - Loaded Furnace configuration
+ * @param furnacePaths - Resolved Furnace workspace paths
+ * @returns Validation target details, or `stock` for stock-only entries
+ */
+function resolveNamedValidationTarget(name, config, furnacePaths) {
+    if (name in config.overrides) {
+        return {
+            type: 'override',
+            componentDir: join(furnacePaths.overridesDir, name),
+        };
+    }
+    if (name in config.custom) {
+        return {
+            type: 'custom',
+            componentDir: join(furnacePaths.customDir, name),
+        };
+    }
+    if (config.stock.includes(name)) {
+        return 'stock';
+    }
+    throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
+}
+/**
+ * Prints the deploy summary after apply and validation complete.
+ * @param result - Aggregate apply result
+ * @param totalErrors - Total validation errors encountered
+ * @param totalWarnings - Total validation warnings encountered
+ * @param componentCount - Number of components considered during deploy
+ * @param skippedValidationCount - Number of components skipped from validation
+ * @param isDryRun - Whether deploy was running in dry-run mode
+ */
+function printDeploymentSummary(result, totalErrors, totalWarnings, componentCount, skippedValidationCount, isDryRun) {
+    const appliedCount = result.applied.length;
+    const skippedCount = result.skipped.length;
+    const applyErrors = result.errors.length + getStepFailureCount(result);
+    const stepErrorCount = result.applied.reduce((sum, a) => sum + (a.stepErrors?.length ?? 0), 0);
+    if (isDryRun) {
+        note(`Would apply ${appliedCount} component(s)\n` +
+            `${result.actions?.length ?? 0} planned action(s)\n` +
+            `${applyErrors} apply error(s)\n` +
+            `${totalErrors} validation error(s), ${totalWarnings} validation warning(s) across ${componentCount} validated component(s)` +
+            (skippedValidationCount > 0
+                ? `\nSkipped validation for ${skippedValidationCount} component(s) with apply errors`
+                : ''), 'Dry Run Summary');
+    }
+    else {
+        note(`Applied ${appliedCount}, skipped ${skippedCount}\n` +
+            `${applyErrors} apply error(s)` +
+            (stepErrorCount > 0 ? `, ${stepErrorCount} registration step error(s)` : '') +
+            `\n` +
+            `${totalErrors} validation error(s), ${totalWarnings} validation warning(s) across ${componentCount} validated component(s)` +
+            (skippedValidationCount > 0
+                ? `\nSkipped validation for ${skippedValidationCount} component(s) with apply errors`
+                : ''), 'Deploy Summary');
+    }
+    const totalProblems = applyErrors + totalErrors;
+    if (totalProblems > 0) {
+        throw new FurnaceError(buildDeployFailureMessage(applyErrors, totalErrors, isDryRun));
+    }
+    outro(isDryRun ? 'Dry run complete (no files modified)' : 'Deploy complete');
+}
+function logApplyResult(result, isDryRun) {
+    if (isDryRun && result.actions && result.actions.length > 0) {
+        info('Planned actions:');
+        for (const action of result.actions) {
+            info(`  [${action.action}] ${action.component}: ${action.description}`);
+        }
+    }
+    else if (isDryRun) {
+        info('No actions would be performed.');
+    }
+    else {
+        for (const applied of result.applied) {
+            success(`${applied.name} (${applied.type}) → ${applied.filesAffected.length} files`);
+        }
+        for (const skipped of result.skipped) {
+            info(`${skipped.name} — ${skipped.reason}`);
+        }
+        for (const applied of result.applied) {
+            if (applied.stepErrors && applied.stepErrors.length > 0) {
+                for (const stepErr of applied.stepErrors) {
+                    warn(`${applied.name}: [${stepErr.step}] ${stepErr.error}`);
+                }
+            }
+        }
+    }
+    for (const err of result.errors) {
+        error(`${err.name} — ${err.error}`);
+    }
+}
+/**
+ * Runs the furnace deploy command: apply components then validate in one step.
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component name to deploy (deploys all if omitted)
+ * @param options - Command options
+ */
+export async function furnaceDeployCommand(projectRoot, name, options = {}) {
+    const isDryRun = options.dryRun ?? false;
+    intro(isDryRun ? 'Furnace Deploy (dry run)' : 'Furnace Deploy');
+    // Verify engine exists
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.engine))) {
+        throw new FurnaceError('Engine directory not found. Run "fireforge download" first.');
+    }
+    // Load furnace config
+    if (!(await furnaceConfigExists(projectRoot))) {
+        throw new FurnaceError('No furnace.json found. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
+    }
+    const config = await loadFurnaceConfig(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    const overrideCount = Object.keys(config.overrides).length;
+    const customCount = Object.keys(config.custom).length;
+    if (overrideCount === 0 && customCount === 0) {
+        info('No components to deploy.');
+        outro('Done');
+        return;
+    }
+    // --- Step 1: Apply ---
+    const applySpinner = spinner(isDryRun ? 'Calculating planned actions...' : 'Applying components to engine...');
+    let result;
+    if (name) {
+        const namedApplyResult = await applyNamedComponent(name, paths.engine, furnacePaths, config, isDryRun);
+        if (namedApplyResult === 'stock') {
+            applySpinner.stop('Apply skipped');
+            info(`"${name}" is a stock component. Stock components are not applied locally.`);
+            outro(isDryRun ? 'Dry run complete (no files modified)' : 'Deploy complete');
+            return;
+        }
+        result = namedApplyResult;
+        // Persist Furnace state for the deployed component so status/change
+        // detection stays accurate after single-component deploys.
+        if (!isDryRun &&
+            result.errors.length === 0 &&
+            getStepFailureCount(result) === 0 &&
+            result.applied.length > 0) {
+            const applied = result.applied[0];
+            await persistSingleComponentState(projectRoot, applied, furnacePaths);
+        }
+    }
+    else {
+        result = await applyAllComponents(projectRoot, isDryRun);
+    }
+    applySpinner.stop(isDryRun ? 'Planned actions calculated' : 'Components applied');
+    logApplyResult(result, isDryRun);
+    // --- Step 2: Validate (read-only, runs even in dry-run) ---
+    const validateSpinner = spinner('Validating components...');
+    const failedComponents = getFailedComponentNames(result);
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    let componentCount = 0;
+    let skippedValidationCount = 0;
+    if (name && failedComponents.has(name)) {
+        skippedValidationCount = 1;
+        validateSpinner.stop('Validation skipped');
+        warn(`Skipping validation for ${name} because apply failed.`);
+    }
+    else if (name) {
+        const target = resolveNamedValidationTarget(name, config, furnacePaths);
+        if (target === 'stock') {
+            validateSpinner.stop('Validation skipped');
+            info(`"${name}" is a stock component. Stock components are not validated locally.`);
+            outro(isDryRun ? 'Dry run complete' : 'Deploy complete');
+            return;
+        }
+        if (!(await pathExists(target.componentDir))) {
+            validateSpinner.stop('Validation failed');
+            throw new FurnaceError(`Component directory not found for "${name}".`, name);
+        }
+        const issues = await validateComponent(target.componentDir, name, target.type, config, projectRoot);
+        componentCount = 1;
+        validateSpinner.stop('Validation complete');
+        if (issues.length === 0) {
+            success(`${name} — all checks passed`);
+        }
+        else {
+            const [errors, warnings] = displayValidationIssues(issues);
+            totalErrors += errors;
+            totalWarnings += warnings;
+        }
+    }
+    else {
+        // Validate all components
+        const results = await validateAllComponents(projectRoot);
+        validateSpinner.stop('Validation complete');
+        for (const [componentName, issues] of results) {
+            if (failedComponents.has(componentName)) {
+                skippedValidationCount++;
+                continue;
+            }
+            componentCount++;
+            if (issues.length === 0) {
+                success(`${componentName} — all checks passed`);
+            }
+            else {
+                const [errors, warnings] = displayValidationIssues(issues);
+                totalErrors += errors;
+                totalWarnings += warnings;
+            }
+        }
+        if (skippedValidationCount > 0) {
+            warn(`Skipped validation for ${skippedValidationCount} component(s) because their apply step failed.`);
+        }
+    }
+    // --- Step 3: Summary ---
+    printDeploymentSummary(result, totalErrors, totalWarnings, componentCount, skippedValidationCount, isDryRun);
+}
+//# sourceMappingURL=deploy.js.map

package/dist/src/commands/furnace/diff.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs the furnace diff command to show changes vs the Firefox original.
+ * Only works for override components.
+ * @param projectRoot - Root directory of the project
+ * @param name - Component name to diff
+ */
+export declare function furnaceDiffCommand(projectRoot: string, name: string): Promise<void>;

package/dist/src/commands/furnace/diff.js

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getProjectPaths } from '../../core/config.js';
+import { getFurnacePaths, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists, readText } from '../../utils/fs.js';
+import { formatErrorText, formatSuccessText, info, intro, outro } from '../../utils/logger.js';
+/**
+ * Computes a simplified line-level diff between two strings.
+ * Note: Uses a prefix/suffix matching algorithm that may combine
+ * multiple scattered changes into a single change region.
+ * For complex diffs with interleaved changes, the output may not
+ * be optimal.
+ */
+function lineDiff(original, modified) {
+    const oldLines = original.split('\n');
+    const newLines = modified.split('\n');
+    // Remove trailing empty element from trailing newline
+    if (oldLines[oldLines.length - 1] === '')
+        oldLines.pop();
+    if (newLines[newLines.length - 1] === '')
+        newLines.pop();
+    const output = [];
+    // Simple diff: find common prefix, common suffix, then show changed region
+    let firstDiff = 0;
+    while (firstDiff < oldLines.length && firstDiff < newLines.length) {
+        if (oldLines[firstDiff] !== newLines[firstDiff])
+            break;
+        firstDiff++;
+    }
+    let lastOldDiff = oldLines.length - 1;
+    let lastNewDiff = newLines.length - 1;
+    while (lastOldDiff > firstDiff && lastNewDiff > firstDiff) {
+        if (oldLines[lastOldDiff] !== newLines[lastNewDiff])
+            break;
+        lastOldDiff--;
+        lastNewDiff--;
+    }
+    // Context lines before the change
+    const contextLines = 3;
+    const contextStart = Math.max(0, firstDiff - contextLines);
+    const contextEndOld = Math.min(oldLines.length - 1, lastOldDiff + contextLines);
+    const contextEndNew = Math.min(newLines.length - 1, lastNewDiff + contextLines);
+    // Leading context
+    for (let i = contextStart; i < firstDiff; i++) {
+        output.push(`  ${oldLines[i]}`);
+    }
+    // Removed lines
+    for (let i = firstDiff; i <= lastOldDiff; i++) {
+        output.push(formatErrorText(`- ${oldLines[i]}`));
+    }
+    // Added lines
+    for (let i = firstDiff; i <= lastNewDiff; i++) {
+        output.push(formatSuccessText(`+ ${newLines[i]}`));
+    }
+    // Trailing context
+    const trailingStart = Math.max(lastOldDiff + 1, lastNewDiff + 1);
+    const trailingEnd = Math.max(contextEndOld, contextEndNew);
+    // Use the new lines for trailing context (they should match old lines here)
+    for (let i = trailingStart; i <= trailingEnd && i < newLines.length; i++) {
+        output.push(`  ${newLines[i]}`);
+    }
+    return output;
+}
+/**
+ * Runs the furnace diff command to show changes vs the Firefox original.
+ * Only works for override components.
+ * @param projectRoot - Root directory of the project
+ * @param name - Component name to diff
+ */
+export async function furnaceDiffCommand(projectRoot, name) {
+    intro('Furnace Diff');
+    const config = await loadFurnaceConfig(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    // Verify the component is an override
+    const overrideConfig = config.overrides[name];
+    if (!overrideConfig) {
+        throw new FurnaceError(`"${name}" is not an override component. The diff command only works for overrides.`, name);
+    }
+    const overrideDir = join(furnacePaths.overridesDir, name);
+    if (!(await pathExists(overrideDir))) {
+        throw new FurnaceError(`Override directory not found: components/overrides/${name}`, name);
+    }
+    const entries = await readdir(overrideDir, { withFileTypes: true });
+    let hasDifferences = false;
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith('.mjs') && !entry.name.endsWith('.css'))
+            continue;
+        const originalPath = join(paths.engine, overrideConfig.basePath, entry.name);
+        const modifiedPath = join(overrideDir, entry.name);
+        if (!(await pathExists(originalPath))) {
+            info(`${entry.name}: original not found in engine (new file)`);
+            hasDifferences = true;
+            continue;
+        }
+        const originalContent = await readText(originalPath);
+        const modifiedContent = await readText(modifiedPath);
+        if (originalContent === modifiedContent) {
+            continue;
+        }
+        hasDifferences = true;
+        info(`--- ${overrideConfig.basePath}/${entry.name}`);
+        info(`+++ components/overrides/${name}/${entry.name}`);
+        const diffLines = lineDiff(originalContent, modifiedContent);
+        for (const line of diffLines) {
+            info(line);
+        }
+        info('');
+    }
+    if (!hasDifferences) {
+        info('No modifications found');
+    }
+    outro('Diff complete');
+}
+//# sourceMappingURL=diff.js.map

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

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import { furnaceApplyCommand } from './apply.js';
+import { furnaceCreateCommand } from './create.js';
+import { furnaceDeployCommand } from './deploy.js';
+import { furnaceDiffCommand } from './diff.js';
+import { furnaceListCommand } from './list.js';
+import { furnaceOverrideCommand } from './override.js';
+import { furnacePreviewCommand } from './preview.js';
+import { furnaceRemoveCommand } from './remove.js';
+import { furnaceScanCommand } from './scan.js';
+import { furnaceStatusCommand } from './status.js';
+import { furnaceValidateCommand } from './validate.js';
+export { furnaceApplyCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRemoveCommand, furnaceScanCommand, furnaceStatusCommand, furnaceValidateCommand, };
+/** Registers the furnace command on the CLI program. */
+export declare function registerFurnace(program: Command, context: CommandContext): void;

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

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Option } from 'commander';
+import { pickDefined } from '../../utils/options.js';
+import { furnaceApplyCommand } from './apply.js';
+import { furnaceCreateCommand } from './create.js';
+import { furnaceDeployCommand } from './deploy.js';
+import { furnaceDiffCommand } from './diff.js';
+import { furnaceListCommand } from './list.js';
+import { furnaceOverrideCommand } from './override.js';
+import { furnacePreviewCommand } from './preview.js';
+import { furnaceRemoveCommand } from './remove.js';
+import { furnaceScanCommand } from './scan.js';
+import { furnaceStatusCommand } from './status.js';
+import { furnaceValidateCommand } from './validate.js';
+export { furnaceApplyCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRemoveCommand, furnaceScanCommand, furnaceStatusCommand, furnaceValidateCommand, };
+/**
+ * Registers read-only Furnace commands such as status, apply, deploy, and scan.
+ * @param furnace - Parent Furnace command
+ * @param context - Shared CLI registration context
+ */
+function registerFurnaceInfoCommands(furnace, context) {
+    const { getProjectRoot, withErrorHandling } = context;
+    furnace
+        .command('status [name]')
+        .description('Show component status and registration details')
+        .action(withErrorHandling(async (name) => {
+        await furnaceStatusCommand(getProjectRoot(), name);
+    }));
+    furnace
+        .command('apply')
+        .description('Apply all components to the engine')
+        .option('--dry-run', 'Show what would be changed without writing')
+        .action(withErrorHandling(async (options) => {
+        await furnaceApplyCommand(getProjectRoot(), pickDefined(options));
+    }));
+    furnace
+        .command('deploy [name]')
+        .description('Apply components and validate in one step')
+        .option('--dry-run', 'Show what would be changed without writing')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceDeployCommand(getProjectRoot(), name, pickDefined(options ?? {}));
+    }));
+    furnace
+        .command('scan')
+        .description('Scan engine for available components')
+        .action(withErrorHandling(async () => {
+        await furnaceScanCommand(getProjectRoot());
+    }));
+    furnace
+        .command('create [name]')
+        .description('Create a new custom component')
+        .option('-d, --description <desc>', 'Component description')
+        .option('--localized', 'Include Fluent l10n support')
+        .option('--no-register', 'Skip customElements.js registration')
+        .option('--with-tests', 'Scaffold Mochitest directory and register in moz.build')
+        .option('--compose <tags>', 'Stock component tags composed internally (comma-separated)', (val) => val.split(',').map((s) => s.trim()))
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceCreateCommand(getProjectRoot(), name, options);
+    }));
+}
+/**
+ * Registers modifying Furnace commands such as override, remove, preview, and diff.
+ * @param furnace - Parent Furnace command
+ * @param context - Shared CLI registration context
+ */
+function registerFurnaceModifyCommands(furnace, context) {
+    const { getProjectRoot, withErrorHandling } = context;
+    furnace
+        .command('override [name]')
+        .description('Fork an existing component for modification')
+        .addOption(new Option('-t, --type <type>', 'Override type').choices(['css-only', 'full']))
+        .option('-d, --description <desc>', 'Description')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceOverrideCommand(getProjectRoot(), name, options);
+    }));
+    furnace
+        .command('list')
+        .description('List all registered components')
+        .action(withErrorHandling(async () => {
+        await furnaceListCommand(getProjectRoot());
+    }));
+    furnace
+        .command('remove <name>')
+        .description('Remove a component from the workspace')
+        .option('-f, --force', 'Skip confirmation')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceRemoveCommand(getProjectRoot(), name, options);
+    }));
+    furnace
+        .command('preview')
+        .description('Start component preview (Storybook)')
+        .option('--install', 'Force reinstall Storybook dependencies')
+        .action(withErrorHandling(async (options) => {
+        await furnacePreviewCommand(getProjectRoot(), options);
+    }));
+    furnace
+        .command('validate [name]')
+        .description('Run accessibility and compatibility checks')
+        .action(withErrorHandling(async (name) => {
+        await furnaceValidateCommand(getProjectRoot(), name);
+    }));
+    furnace
+        .command('diff <name>')
+        .description('Show changes vs Firefox original (overrides only)')
+        .action(withErrorHandling(async (name) => {
+        await furnaceDiffCommand(getProjectRoot(), name);
+    }));
+}
+/** Registers the furnace command on the CLI program. */
+export function registerFurnace(program, context) {
+    const { getProjectRoot, withErrorHandling } = context;
+    const furnace = program
+        .command('furnace')
+        .description('Component management (Furnace)')
+        .action(withErrorHandling(async () => {
+        await furnaceStatusCommand(getProjectRoot());
+    }));
+    registerFurnaceInfoCommands(furnace, context);
+    registerFurnaceModifyCommands(furnace, context);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/commands/furnace/list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runs the furnace list command to display all registered components.
+ * @param projectRoot - Root directory of the project
+ */
+export declare function furnaceListCommand(projectRoot: string): Promise<void>;

package/dist/src/commands/furnace/list.js

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { furnaceConfigExists, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { info, intro, note, outro } from '../../utils/logger.js';
+/**
+ * Runs the furnace list command to display all registered components.
+ * @param projectRoot - Root directory of the project
+ */
+export async function furnaceListCommand(projectRoot) {
+    intro('Furnace List');
+    if (!(await furnaceConfigExists(projectRoot))) {
+        info('No components configured. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
+        outro('Done');
+        return;
+    }
+    const config = await loadFurnaceConfig(projectRoot);
+    const stockCount = config.stock.length;
+    const overrideCount = Object.keys(config.overrides).length;
+    const customCount = Object.keys(config.custom).length;
+    const total = stockCount + overrideCount + customCount;
+    if (total === 0) {
+        info('No components configured. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
+        outro('Done');
+        return;
+    }
+    // --- Stock ---
+    if (stockCount > 0) {
+        info('Stock:');
+        for (const name of config.stock) {
+            info(`  ${name}`);
+        }
+    }
+    // --- Overrides ---
+    if (overrideCount > 0) {
+        info('Overrides:');
+        for (const [name, entry] of Object.entries(config.overrides)) {
+            let line = `  ${name} (${entry.type})`;
+            if (entry.description) {
+                line += ` — ${entry.description}`;
+            }
+            info(line);
+        }
+    }
+    // --- Custom ---
+    if (customCount > 0) {
+        info('Custom:');
+        for (const [name, entry] of Object.entries(config.custom)) {
+            const flags = [];
+            if (entry.localized)
+                flags.push('localized');
+            if (entry.register)
+                flags.push('registered');
+            let line = `  ${name}`;
+            if (entry.description) {
+                line += ` — ${entry.description}`;
+            }
+            if (flags.length > 0) {
+                line += ` [${flags.join(', ')}]`;
+            }
+            info(line);
+        }
+    }
+    note(`Stock: ${stockCount}  Overrides: ${overrideCount}  Custom: ${customCount}  Total: ${total}`, 'Summary');
+    outro('List complete');
+}
+//# sourceMappingURL=list.js.map