@hominis/fireforge 0.10.1 → 0.11.1

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

@@ -1,112 +1,92 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getProjectPaths } from '../../core/config.js';
+import { getProjectPaths, loadState } from '../../core/config.js';
+import { diffLines, renderHunks } from '../../core/diff-hunks.js';
+import { getOverrideEngineTargetPath } from '../../core/furnace-apply-helpers.js';
 import { getFurnacePaths, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { isComponentSourceFile, resolveFtlDir } from '../../core/furnace-constants.js';
+import { getFileContentAtRef } from '../../core/git-file-ops.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.
+ * Renders a multi-hunk unified diff between the two strings and returns a
+ * flat list of display-ready lines. Each line has already had its marker
+ * prefix and color applied by this function; the caller just emits them.
+ *
+ * Pure delegation to the `diff-hunks` module — kept here as a thin wrapper
+ * so the command file does not need to care about the hunk data shape.
  */
-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;
+function formatUnifiedDiff(original, modified) {
+    const hunks = diffLines(original, modified, 3);
+    return renderHunks(hunks).map((line) => {
+        switch (line.kind) {
+            case 'removed':
+                return formatErrorText(line.text);
+            case 'added':
+                return formatSuccessText(line.text);
+            default:
+                return line.text;
+        }
+    });
 }
 /**
- * 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
+ * Diffs an override component against its Firefox baseline at baseCommit.
  */
-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
+async function diffOverride(name, projectRoot, config) {
     const overrideConfig = config.overrides[name];
     if (!overrideConfig) {
-        throw new FurnaceError(`"${name}" is not an override component. The diff command only works for overrides.`, name);
+        throw new FurnaceError(`Override "${name}" not found in furnace.json.`, name);
     }
+    const paths = getProjectPaths(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    const ftlDir = resolveFtlDir(config.ftlBasePath);
     const overrideDir = join(furnacePaths.overridesDir, name);
     if (!(await pathExists(overrideDir))) {
         throw new FurnaceError(`Override directory not found: components/overrides/${name}`, name);
     }
+    // Prefer the per-override baseCommit (survives download --force); fall back
+    // to the project-wide value for overrides created before this field existed.
+    const state = await loadState(projectRoot);
+    const baseCommit = overrideConfig.baseCommit ?? state.baseCommit;
+    if (!baseCommit) {
+        throw new FurnaceError('Cannot diff: baseCommit not found. Re-run "fireforge download" to establish a baseline.', 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'))
+        if (!isComponentSourceFile(entry.name))
             continue;
-        const originalPath = join(paths.engine, overrideConfig.basePath, entry.name);
+        // git show takes a repo-relative path. paths.engine IS the repo root.
+        const enginePath = getOverrideEngineTargetPath(paths.engine, overrideConfig, entry.name, ftlDir).slice(paths.engine.length + 1);
         const modifiedPath = join(overrideDir, entry.name);
-        if (!(await pathExists(originalPath))) {
+        const baselineDisplayPath = enginePath;
+        let originalContent;
+        try {
+            originalContent = await getFileContentAtRef(paths.engine, enginePath, baseCommit);
+        }
+        catch (error) {
+            throw new FurnaceError(`Cannot read baseline for "${entry.name}" at commit ${baseCommit.slice(0, 8)}: ` +
+                `${error instanceof Error ? error.message : String(error)}. ` +
+                `The commit may no longer exist in the engine history (e.g. after a re-download). ` +
+                `Run "fireforge furnace refresh --reset-base ${name}" to establish a new baseline.`, name);
+        }
+        if (originalContent === null) {
             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(`--- ${baselineDisplayPath}`);
         info(`+++ components/overrides/${name}/${entry.name}`);
-        const diffLines = lineDiff(originalContent, modifiedContent);
-        for (const line of diffLines) {
+        for (const line of formatUnifiedDiff(originalContent, modifiedContent)) {
             info(line);
         }
         info('');
@@ -114,6 +94,95 @@ export async function furnaceDiffCommand(projectRoot, name) {
     if (!hasDifferences) {
         info('No modifications found');
     }
+}
+/**
+ * Diffs a custom component's workspace files against the engine-deployed copy.
+ * Shows what would change (or has changed) on the next `furnace apply`.
+ */
+async function diffCustom(name, projectRoot, config) {
+    const customConfig = config.custom[name];
+    if (!customConfig) {
+        throw new FurnaceError(`Custom component "${name}" not found in furnace.json.`, name);
+    }
+    const paths = getProjectPaths(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    const customDir = join(furnacePaths.customDir, name);
+    if (!(await pathExists(customDir))) {
+        throw new FurnaceError(`Custom component directory not found: components/custom/${name}`, name);
+    }
+    const engineDir = join(paths.engine, customConfig.targetPath);
+    const entries = await readdir(customDir, { withFileTypes: true });
+    let hasDifferences = false;
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!isComponentSourceFile(entry.name))
+            continue;
+        const workspacePath = join(customDir, entry.name);
+        const deployedPath = join(engineDir, entry.name);
+        const workspaceContent = await readText(workspacePath);
+        if (!(await pathExists(deployedPath))) {
+            info(`${entry.name}: not yet deployed to engine (new file)`);
+            hasDifferences = true;
+            continue;
+        }
+        const deployedContent = await readText(deployedPath);
+        if (workspaceContent === deployedContent) {
+            continue;
+        }
+        hasDifferences = true;
+        info(`--- engine/${customConfig.targetPath}/${entry.name}`);
+        info(`+++ components/custom/${name}/${entry.name}`);
+        for (const line of formatUnifiedDiff(deployedContent, workspaceContent)) {
+            info(line);
+        }
+        info('');
+    }
+    if (!hasDifferences) {
+        info('No differences between workspace and engine');
+    }
+}
+/**
+ * Runs the furnace diff command.
+ *
+ * For overrides: shows changes vs the Firefox original at baseCommit.
+ * For custom components: shows workspace vs engine-deployed copy.
+ * When no name is provided, diffs all override and custom components.
+ *
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component name to diff (diffs all when omitted)
+ */
+export async function furnaceDiffCommand(projectRoot, name) {
+    intro('Furnace Diff');
+    const config = await loadFurnaceConfig(projectRoot);
+    if (name) {
+        if (name in config.overrides) {
+            await diffOverride(name, projectRoot, config);
+        }
+        else if (name in config.custom) {
+            await diffCustom(name, projectRoot, config);
+        }
+        else {
+            throw new FurnaceError(`"${name}" is not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
+        }
+    }
+    else {
+        const overrideNames = Object.keys(config.overrides);
+        const customNames = Object.keys(config.custom);
+        if (overrideNames.length === 0 && customNames.length === 0) {
+            info('No components to diff.');
+            outro('Diff complete');
+            return;
+        }
+        for (const overrideName of overrideNames) {
+            info(`\n── ${overrideName} (override) ──`);
+            await diffOverride(overrideName, projectRoot, config);
+        }
+        for (const customName of customNames) {
+            info(`\n── ${customName} (custom) ──`);
+            await diffCustom(customName, projectRoot, config);
+        }
+    }
     outro('Diff complete');
 }
 //# sourceMappingURL=diff.js.map

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

@@ -4,13 +4,17 @@ import { furnaceApplyCommand } from './apply.js';
 import { furnaceCreateCommand } from './create.js';
 import { furnaceDeployCommand } from './deploy.js';
 import { furnaceDiffCommand } from './diff.js';
+import { furnaceInitCommand } from './init.js';
 import { furnaceListCommand } from './list.js';
-import { furnaceOverrideCommand } from './override.js';
+import { furnaceBatchOverrideCommand, furnaceOverrideCommand } from './override.js';
 import { furnacePreviewCommand } from './preview.js';
+import { furnaceRefreshCommand } from './refresh.js';
 import { furnaceRemoveCommand } from './remove.js';
+import { furnaceRenameCommand } from './rename.js';
 import { furnaceScanCommand } from './scan.js';
 import { furnaceStatusCommand } from './status.js';
+import { furnaceSyncCommand } from './sync.js';
 import { furnaceValidateCommand } from './validate.js';
-export { furnaceApplyCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRemoveCommand, furnaceScanCommand, furnaceStatusCommand, furnaceValidateCommand, };
+export { furnaceApplyCommand, furnaceBatchOverrideCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceInitCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRefreshCommand, furnaceRemoveCommand, furnaceRenameCommand, furnaceScanCommand, furnaceStatusCommand, furnaceSyncCommand, 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

@@ -5,16 +5,21 @@ import { furnaceApplyCommand } from './apply.js';
 import { furnaceCreateCommand } from './create.js';
 import { furnaceDeployCommand } from './deploy.js';
 import { furnaceDiffCommand } from './diff.js';
+import { furnaceInitCommand } from './init.js';
 import { furnaceListCommand } from './list.js';
-import { furnaceOverrideCommand } from './override.js';
+import { furnaceBatchOverrideCommand, furnaceOverrideCommand } from './override.js';
 import { furnacePreviewCommand } from './preview.js';
+import { furnaceRefreshCommand } from './refresh.js';
 import { furnaceRemoveCommand } from './remove.js';
+import { furnaceRenameCommand } from './rename.js';
 import { furnaceScanCommand } from './scan.js';
 import { furnaceStatusCommand } from './status.js';
+import { furnaceSyncCommand } from './sync.js';
 import { furnaceValidateCommand } from './validate.js';
-export { furnaceApplyCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRemoveCommand, furnaceScanCommand, furnaceStatusCommand, furnaceValidateCommand, };
+export { furnaceApplyCommand, furnaceBatchOverrideCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceInitCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRefreshCommand, furnaceRemoveCommand, furnaceRenameCommand, furnaceScanCommand, furnaceStatusCommand, furnaceSyncCommand, furnaceValidateCommand, };
 /**
- * Registers read-only Furnace commands such as status, apply, deploy, and scan.
+ * Registers Furnace commands for querying component state: status, scan,
+ * and action commands like apply, deploy, and create.
  * @param furnace - Parent Furnace command
  * @param context - Shared CLI registration context
  */
@@ -27,24 +32,38 @@ function registerFurnaceInfoCommands(furnace, context) {
         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));
+        .command('apply [name]')
+        .description('Apply components to the engine (optionally a single component)')
+        .option('--dry-run', 'Show what would be changed without writing (reads may overlap concurrent mutations)')
+        .option('--force', 'Proceed despite baseVersion drift (stale overrides)')
+        .option('-w, --watch', 'Watch component directories and re-apply on changes')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceApplyCommand(getProjectRoot(), name, pickDefined(options ?? {}));
     }));
     furnace
         .command('deploy [name]')
         .description('Apply components and validate in one step')
-        .option('--dry-run', 'Show what would be changed without writing')
+        .option('--dry-run', 'Show what would be changed without writing (reads may overlap concurrent mutations)')
+        .option('--force', 'Proceed despite baseVersion drift (stale overrides)')
+        .option('--skip-validate', 'Skip the validation step (apply only)')
         .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());
+        .option('--deep', 'Search additional Firefox directories beyond the default widgets path')
+        .action(withErrorHandling(async (options) => {
+        await furnaceScanCommand(getProjectRoot(), pickDefined(options));
+    }));
+    furnace
+        .command('init')
+        .description('Initialize furnace.json with project settings')
+        .option('-p, --prefix <prefix>', 'Component prefix (e.g. "moz-", "ff-")')
+        .option('--ftl-base-path <path>', 'Fluent l10n base path')
+        .option('--force', 'Overwrite existing furnace.json')
+        .action(withErrorHandling(async (options) => {
+        await furnaceInitCommand(getProjectRoot(), options);
     }));
     furnace
         .command('create [name]')
@@ -53,36 +72,43 @@ function registerFurnaceInfoCommands(furnace, context) {
         .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()))
+        .option('--compose <tags>', 'Record stock tags composed internally (metadata only, 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.
+ * Registers Furnace commands for authoring, inspection, and maintenance:
+ * override, list, remove, preview, validate, diff, refresh, and rename.
  * @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')
+        .command('override [names...]')
+        .description('Fork one or more existing components 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);
+        .action(withErrorHandling(async (names, options) => {
+        if (names.length <= 1) {
+            await furnaceOverrideCommand(getProjectRoot(), names[0], options);
+        }
+        else {
+            await furnaceBatchOverrideCommand(getProjectRoot(), names, options);
+        }
     }));
     furnace
         .command('list')
         .description('List all registered components')
-        .action(withErrorHandling(async () => {
-        await furnaceListCommand(getProjectRoot());
+        .option('-v, --verbose', 'Show per-component health indicators (clean/modified/not applied)')
+        .action(withErrorHandling(async (options) => {
+        await furnaceListCommand(getProjectRoot(), options);
     }));
     furnace
         .command('remove <name>')
         .description('Remove a component from the workspace')
-        .option('-f, --force', 'Skip confirmation')
+        .option('-y, --yes', 'Skip confirmation')
         .action(withErrorHandling(async (name, options) => {
         await furnaceRemoveCommand(getProjectRoot(), name, options);
     }));
@@ -96,22 +122,47 @@ function registerFurnaceModifyCommands(furnace, context) {
     furnace
         .command('validate [name]')
         .description('Run accessibility and compatibility checks')
-        .action(withErrorHandling(async (name) => {
-        await furnaceValidateCommand(getProjectRoot(), name);
+        .option('--fix', 'Auto-fix registration issues (missing jar.mn entries, customElements.js)')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceValidateCommand(getProjectRoot(), name, pickDefined(options ?? {}));
     }));
     furnace
-        .command('diff <name>')
-        .description('Show changes vs Firefox original (overrides only)')
+        .command('diff [name]')
+        .description('Show changes vs baseline (overrides: vs Firefox original, custom: vs engine). Shows all components when name is omitted.')
         .action(withErrorHandling(async (name) => {
         await furnaceDiffCommand(getProjectRoot(), name);
     }));
+    furnace
+        .command('refresh [name]')
+        .description('Merge upstream Firefox changes into overrides (three-way merge)')
+        .option('--dry-run', 'Show what would change without modifying files')
+        .option('-a, --all', 'Refresh all overrides in a single batch')
+        .addOption(new Option('-s, --strategy <strategy>', 'Auto-resolve conflicts (ours = keep local, theirs = accept upstream)').choices(['ours', 'theirs']))
+        .option('--reset-base', 'Reset baseline to current engine HEAD (skips three-way merge, recovers from missing baseCommit)')
+        .action(withErrorHandling(async (name, options) => {
+        await furnaceRefreshCommand(getProjectRoot(), name, pickDefined(options));
+    }));
+    furnace
+        .command('rename <old-name> <new-name>')
+        .description('Rename a component (updates files, config, and registrations)')
+        .action(withErrorHandling(async (oldName, newName) => {
+        await furnaceRenameCommand(getProjectRoot(), oldName, newName);
+    }));
+    furnace
+        .command('sync')
+        .description('Refresh drifted overrides and re-apply all components (recommended after fireforge download)')
+        .option('--dry-run', 'Show what would change without modifying files (reads may overlap concurrent mutations)')
+        .addOption(new Option('-s, --strategy <strategy>', 'Auto-resolve merge conflicts (ours = keep local, theirs = accept upstream)').choices(['ours', 'theirs']))
+        .action(withErrorHandling(async (options) => {
+        await furnaceSyncCommand(getProjectRoot(), pickDefined(options));
+    }));
 }
 /** 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)')
+        .description('Component management — create, override, apply, deploy, diff, validate, sync (run furnace --help for all subcommands)')
         .action(withErrorHandling(async () => {
         await furnaceStatusCommand(getProjectRoot());
     }));

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

@@ -0,0 +1,11 @@
+/**
+ * Runs the furnace init command to create a default furnace.json with
+ * user-specified settings.
+ * @param projectRoot - Root directory of the project
+ * @param options - Init options
+ */
+export declare function furnaceInitCommand(projectRoot: string, options?: {
+    prefix?: string;
+    ftlBasePath?: string;
+    force?: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { text } from '@clack/prompts';
+import { createDefaultFurnaceConfig, furnaceConfigExists, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { cancel, info, intro, isCancel, note, outro, success } from '../../utils/logger.js';
+/**
+ * Runs the furnace init command to create a default furnace.json with
+ * user-specified settings.
+ * @param projectRoot - Root directory of the project
+ * @param options - Init options
+ */
+export async function furnaceInitCommand(projectRoot, options = {}) {
+    intro('Furnace Init');
+    if ((await furnaceConfigExists(projectRoot)) && !options.force) {
+        throw new FurnaceError('furnace.json already exists. Use --force to overwrite it.');
+    }
+    const config = createDefaultFurnaceConfig();
+    const isInteractive = process.stdin.isTTY;
+    // Resolve componentPrefix
+    if (options.prefix !== undefined) {
+        config.componentPrefix = options.prefix;
+    }
+    else if (isInteractive) {
+        const prefixResult = await text({
+            message: 'Component prefix (e.g. "moz-", "ff-")',
+            initialValue: config.componentPrefix,
+            validate: (value) => {
+                if (!value)
+                    return 'Prefix is required';
+                return undefined;
+            },
+        });
+        if (isCancel(prefixResult)) {
+            cancel('Init cancelled');
+            return;
+        }
+        config.componentPrefix = prefixResult;
+    }
+    // Resolve ftlBasePath
+    if (options.ftlBasePath !== undefined) {
+        if (options.ftlBasePath.includes('..')) {
+            throw new FurnaceError('ftlBasePath must not contain ".." (path traversal)');
+        }
+        config.ftlBasePath = options.ftlBasePath;
+    }
+    else if (isInteractive) {
+        const ftlResult = await text({
+            message: 'Fluent l10n base path (leave empty for default)',
+            placeholder: 'toolkit/locales/en-US/toolkit/global',
+        });
+        if (isCancel(ftlResult)) {
+            cancel('Init cancelled');
+            return;
+        }
+        const ftlValue = ftlResult.trim();
+        if (ftlValue) {
+            if (ftlValue.includes('..')) {
+                throw new FurnaceError('ftlBasePath must not contain ".." (path traversal)');
+            }
+            config.ftlBasePath = ftlValue;
+        }
+    }
+    await writeFurnaceConfig(projectRoot, config);
+    success('Created furnace.json');
+    const lines = [`Component prefix: ${config.componentPrefix}`];
+    if (config.ftlBasePath) {
+        lines.push(`FTL base path: ${config.ftlBasePath}`);
+    }
+    note(lines.join('\n'), 'Configuration');
+    info('Next steps:\n' +
+        '  fireforge furnace scan        — discover engine components\n' +
+        '  fireforge furnace create       — create a new custom component\n' +
+        '  fireforge furnace override     — fork an existing component');
+    outro('Init complete');
+}
+//# sourceMappingURL=init.js.map

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

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

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

@@ -1,11 +1,30 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { furnaceConfigExists, loadFurnaceConfig } from '../../core/furnace-config.js';
-import { info, intro, note, outro } from '../../utils/logger.js';
+import { join } from 'node:path';
+import { extractComponentChecksums, hasComponentChanged, } from '../../core/furnace-apply-helpers.js';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from '../../core/furnace-config.js';
+import { pathExists } from '../../utils/fs.js';
+import { formatErrorText, formatSuccessText, info, intro, note, outro, } from '../../utils/logger.js';
+/**
+ * Returns a short health indicator for a component directory based on whether
+ * its workspace checksums have changed since the last apply.
+ */
+async function getHealthIndicator(componentDir, type, name, appliedChecksums) {
+    if (!(await pathExists(componentDir))) {
+        return formatErrorText('missing');
+    }
+    const previous = extractComponentChecksums(appliedChecksums, type, name);
+    if (Object.keys(previous).length === 0) {
+        return formatErrorText('not applied');
+    }
+    const changed = await hasComponentChanged(componentDir, previous);
+    return changed ? formatErrorText('modified') : formatSuccessText('clean');
+}
 /**
  * Runs the furnace list command to display all registered components.
  * @param projectRoot - Root directory of the project
+ * @param options - List options
  */
-export async function furnaceListCommand(projectRoot) {
+export async function furnaceListCommand(projectRoot, options = {}) {
     intro('Furnace List');
     if (!(await furnaceConfigExists(projectRoot))) {
         info('No components configured. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
@@ -22,6 +41,9 @@ export async function furnaceListCommand(projectRoot) {
         outro('Done');
         return;
     }
+    const showHealth = options.verbose ?? false;
+    const furnacePaths = showHealth ? getFurnacePaths(projectRoot) : undefined;
+    const state = showHealth ? await loadFurnaceState(projectRoot) : undefined;
     // --- Stock ---
     if (stockCount > 0) {
         info('Stock:');
@@ -37,6 +59,11 @@ export async function furnaceListCommand(projectRoot) {
             if (entry.description) {
                 line += ` — ${entry.description}`;
             }
+            if (showHealth && furnacePaths && state) {
+                const componentDir = join(furnacePaths.overridesDir, name);
+                const health = await getHealthIndicator(componentDir, 'override', name, state.appliedChecksums);
+                line += ` [${health}]`;
+            }
             info(line);
         }
     }
@@ -56,6 +83,11 @@ export async function furnaceListCommand(projectRoot) {
             if (flags.length > 0) {
                 line += ` [${flags.join(', ')}]`;
             }
+            if (showHealth && furnacePaths && state) {
+                const componentDir = join(furnacePaths.customDir, name);
+                const health = await getHealthIndicator(componentDir, 'custom', name, state.appliedChecksums);
+                line += ` [${health}]`;
+            }
             info(line);
         }
     }

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

@@ -6,3 +6,11 @@ import type { FurnaceOverrideOptions } from '../../types/commands/index.js';
  * @param options - CLI options for non-interactive mode
  */
 export declare function furnaceOverrideCommand(projectRoot: string, name?: string, options?: FurnaceOverrideOptions): Promise<void>;
+/**
+ * Creates multiple overrides in a single invocation. Each component is validated
+ * and created sequentially; failures on one component do not block the rest.
+ * @param projectRoot - Root directory of the project
+ * @param names - Component tag names to override
+ * @param options - CLI options applied to all overrides
+ */
+export declare function furnaceBatchOverrideCommand(projectRoot: string, names: string[], options?: FurnaceOverrideOptions): Promise<void>;