@hominis/fireforge 0.10.0 → 0.11.0

package/dist/src/cli.js

@@ -1,31 +1,8 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { Command } from 'commander';
-import { registerBootstrap } from './commands/bootstrap.js';
-import { registerBuild } from './commands/build.js';
-import { registerConfig } from './commands/config.js';
-import { registerDiscard } from './commands/discard.js';
-import { registerDoctor } from './commands/doctor.js';
-import { registerDownload } from './commands/download.js';
-import { registerExport } from './commands/export.js';
-import { registerExportAll } from './commands/export-all.js';
-import { registerFurnace } from './commands/furnace/index.js';
-import { registerImport } from './commands/import.js';
-import { registerLint } from './commands/lint.js';
-import { registerPackage } from './commands/package.js';
-import { registerReExport } from './commands/re-export.js';
-import { registerRebase } from './commands/rebase.js';
-import { registerRegister } from './commands/register.js';
-import { registerReset } from './commands/reset.js';
-import { registerResolve } from './commands/resolve.js';
-import { registerRun } from './commands/run.js';
-import { registerSetup } from './commands/setup.js';
-import { registerStatus } from './commands/status.js';
-import { registerTest } from './commands/test.js';
-import { registerToken } from './commands/token.js';
-import { registerWatch } from './commands/watch.js';
-import { registerWire } from './commands/wire.js';
+import { Command, Help } from 'commander';
+import { COMMAND_MANIFEST } from './commands/manifest.js';
 import { CancellationError, CommandError, FireForgeError } from './errors/base.js';
 import { ExitCode } from './errors/codes.js';
 import { toError } from './utils/errors.js';
@@ -78,23 +55,31 @@ export function resetBrokenPipeHandlerForTests() {
     state[brokenPipeInstalledKey] = undefined;
     state[brokenPipeListenerKey] = undefined;
 }
+/**
+ * Maximum number of directory levels to walk when searching for
+ * `fireforge.json`. Guards against symlink cycles and pathologically
+ * deep trees.
+ */
+const MAX_PROJECT_ROOT_WALK_DEPTH = 50;
 /**
  * Gets the project root directory.
  * Walks up from the current working directory until a fireforge.json is found.
- * Falls back to the current working directory when no project root is found.
+ * Throws when no fireforge.json is found within the walk depth limit.
  */
 export function getProjectRoot() {
     const start = resolve(process.cwd());
     let current = start;
-    for (;;) {
+    for (let depth = 0; depth < MAX_PROJECT_ROOT_WALK_DEPTH; depth++) {
         if (existsSync(join(current, 'fireforge.json'))) {
             return current;
         }
         const parent = dirname(current);
         if (parent === current)
-            return start;
+            break;
         current = parent;
     }
+    throw new Error('Could not find fireforge.json in any parent directory. ' +
+        'Are you inside a FireForge project?');
 }
 /**
  * Wraps a command handler with error handling.
@@ -127,6 +112,117 @@ export function withErrorHandling(handler) {
         }
     };
 }
+/** Human-readable labels for command groups, in display order. */
+const GROUP_LABELS = new Map([
+    ['project', 'Project'],
+    ['engine', 'Engine'],
+    ['workflow', 'Workflow'],
+    ['components', 'Components'],
+    ['diagnostics', 'Diagnostics'],
+]);
+/**
+ * Builds a grouped help formatter that replaces Commander's flat command
+ * list with sections labelled by manifest group.
+ */
+function buildGroupedHelpFormatter(manifest) {
+    const commandGroupMap = new Map();
+    for (const entry of manifest) {
+        commandGroupMap.set(entry.name, entry.group);
+    }
+    return (cmd, helper) => {
+        // For subcommands (e.g. `furnace --help`), fall back to Commander's
+        // default formatting by calling the prototype method directly.
+        if (cmd.parent) {
+            return Help.prototype.formatHelp.call(helper, cmd, helper);
+        }
+        const termWidth = helper.padWidth(cmd, helper);
+        const helpWidth = helper.helpWidth ?? 80;
+        const output = [];
+        // Usage
+        output.push(`Usage: ${helper.commandUsage(cmd)}`, '');
+        // Description
+        const desc = helper.commandDescription(cmd);
+        if (desc) {
+            output.push(desc, '');
+        }
+        // Options
+        const optionLines = helper.visibleOptions(cmd).map((opt) => {
+            const term = helper.optionTerm(opt);
+            const desc = helper.optionDescription(opt);
+            return formatHelpLine(term, desc, termWidth, helpWidth);
+        });
+        if (optionLines.length > 0) {
+            output.push('Options:');
+            output.push(...optionLines);
+            output.push('');
+        }
+        // Grouped commands
+        const visibleCommands = helper.visibleCommands(cmd);
+        const grouped = new Map();
+        const otherLines = [];
+        for (const sub of visibleCommands) {
+            const name = sub.name();
+            const group = commandGroupMap.get(name);
+            const term = helper.subcommandTerm(sub);
+            const desc = helper.subcommandDescription(sub);
+            const line = formatHelpLine(term, desc, termWidth, helpWidth);
+            if (!group) {
+                // Built-in commands (e.g. "help") go to the end
+                otherLines.push(line);
+                continue;
+            }
+            const label = GROUP_LABELS.get(group) ?? group;
+            const lines = grouped.get(label) ?? [];
+            lines.push(line);
+            grouped.set(label, lines);
+        }
+        for (const [, displayLabel] of GROUP_LABELS) {
+            const lines = grouped.get(displayLabel);
+            if (!lines || lines.length === 0)
+                continue;
+            output.push(`${displayLabel}:`);
+            output.push(...lines);
+            output.push('');
+        }
+        if (otherLines.length > 0) {
+            output.push(...otherLines);
+            output.push('');
+        }
+        return output.join('\n');
+    };
+}
+/** Formats a single help line with term and description, wrapping as needed. */
+function formatHelpLine(term, description, termWidth, helpWidth) {
+    const padding = ' '.repeat(termWidth - term.length);
+    const fullLine = `  ${term}${padding}  ${description}`;
+    if (fullLine.length <= helpWidth || !description) {
+        return fullLine;
+    }
+    // Wrap long descriptions
+    const descWidth = helpWidth - termWidth - 4;
+    if (descWidth < 20) {
+        return fullLine;
+    }
+    const words = description.split(' ');
+    const lines = [];
+    let currentLine = '';
+    for (const word of words) {
+        if (currentLine.length + word.length + 1 > descWidth && currentLine.length > 0) {
+            lines.push(currentLine);
+            currentLine = word;
+        }
+        else {
+            currentLine = currentLine.length > 0 ? `${currentLine} ${word}` : word;
+        }
+    }
+    if (currentLine.length > 0) {
+        lines.push(currentLine);
+    }
+    const indent = ' '.repeat(termWidth + 4);
+    const first = lines[0] ?? '';
+    const rest = lines.slice(1).map((l) => `${indent}${l}`);
+    return [`  ${term}${padding}  ${first}`, ...rest].join('\n');
+}
 /**
  * Creates and configures the CLI program.
  */
@@ -143,31 +239,14 @@ export function createProgram() {
             setVerbose(true);
         }
     });
+    const groupedFormatter = buildGroupedHelpFormatter(COMMAND_MANIFEST);
+    program.configureHelp({
+        formatHelp: groupedFormatter,
+    });
     const ctx = { getProjectRoot, withErrorHandling };
-    registerSetup(program, ctx);
-    registerDownload(program, ctx);
-    registerBootstrap(program, ctx);
-    registerImport(program, ctx);
-    registerResolve(program, ctx);
-    registerBuild(program, ctx);
-    registerRun(program, ctx);
-    registerStatus(program, ctx);
-    registerReset(program, ctx);
-    registerDiscard(program, ctx);
-    registerExport(program, ctx);
-    registerExportAll(program, ctx);
-    registerReExport(program, ctx);
-    registerRebase(program, ctx);
-    registerPackage(program, ctx);
-    registerWatch(program, ctx);
-    registerTest(program, ctx);
-    registerConfig(program, ctx);
-    registerDoctor(program, ctx);
-    registerRegister(program, ctx);
-    registerWire(program, ctx);
-    registerToken(program, ctx);
-    registerLint(program, ctx);
-    registerFurnace(program, ctx);
+    for (const entry of COMMAND_MANIFEST) {
+        entry.register(program, ctx);
+    }
     return program;
 }
 /**

package/dist/src/commands/bootstrap.js

@@ -52,12 +52,16 @@ export async function bootstrapCommand(projectRoot) {
         throw new BootstrapError();
     }
     // mach bootstrap may exit 0 even when sub-downloads fail (e.g. HTTP 403).
-    // Scan output for known failure patterns and surface them as warnings.
+    // Scan output for known failure patterns and surface them prominently.
     const softFailure = buildBootstrapFailureMessage(`${result.stdout}\n${result.stderr}`);
     if (softFailure) {
         info('');
+        error('Bootstrap completed with issues:');
         info(softFailure);
-        info('Bootstrap exited successfully but the issues above may cause build failures.');
+        info('Run "fireforge doctor" to verify your build environment. ' +
+            'These issues may cause build failures if not resolved.');
+        outro('Build dependencies installed with warnings');
+        return;
     }
     outro('Build dependencies installed successfully!');
 }

package/dist/src/commands/build.js

@@ -6,8 +6,8 @@ import { getProjectPaths, loadConfig } from '../core/config.js';
 import { build, buildArtifactMismatchMessage, buildUI, hasBuildArtifacts } from '../core/mach.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
-import { pathExists } from '../utils/fs.js';
-import { error, info, intro, outro, verbose } from '../utils/logger.js';
+import { checkDiskSpace, pathExists } from '../utils/fs.js';
+import { error, info, intro, outro, verbose, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 import { isPositiveInteger } from '../utils/validation.js';
 function parseJobCount(value) {
@@ -40,6 +40,8 @@ export async function buildCommand(projectRoot, options) {
     const config = await loadConfig(projectRoot);
     const paths = getProjectPaths(projectRoot);
     validateBrandOverride(config.binaryName, options.brand);
+    // Disk space pre-flight: a full Firefox build can be ~20 GB
+    await checkDiskSpace(projectRoot, 20 * 1024 * 1024 * 1024, warn);
     // Check if engine exists
     if (!(await pathExists(paths.engine))) {
         throw new GeneralError('Firefox source not found. Run "fireforge download" first.');

package/dist/src/commands/discard.js

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { confirm } from '@clack/prompts';
 import { getProjectPaths } from '../core/config.js';
+import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { isGitRepository } from '../core/git.js';
 import { discardStatusEntry } from '../core/git-file-ops.js';
 import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { GitError } from '../errors/git.js';
 import { pathExists } from '../utils/fs.js';
-import { info, intro, isCancel, outro, spinner } from '../utils/logger.js';
+import { info, intro, isCancel, outro, spinner, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 /**
  * Runs the discard command to revert changes to a specific file.
@@ -32,10 +33,10 @@ export async function discardCommand(projectRoot, file, options = {}) {
     if (!statusEntry) {
         throw new GeneralError(`File "${file}" has no changes to discard.`);
     }
-    if (!options.force && !options.dryRun) {
+    if (!options.yes && !options.dryRun) {
         const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
         if (!isInteractive) {
-            throw new InvalidArgumentError('Interactive confirmation not available. Use --force flag to discard without confirmation.', 'Use: fireforge discard <file> --force');
+            throw new InvalidArgumentError('Interactive confirmation not available. Use --yes flag to discard without confirmation.', 'Use: fireforge discard <file> --yes');
         }
         const confirmed = await confirm({
             message: `Discard all changes to ${statusEntry.file}?`,
@@ -58,6 +59,17 @@ export async function discardCommand(projectRoot, file, options = {}) {
     try {
         await discardStatusEntry(paths.engine, statusEntry);
         s.stop(`Discarded changes to ${file}`);
+        // Warn when the discarded file is managed by Furnace so the user knows
+        // to re-apply if they want the component's deployed state back.
+        try {
+            const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
+            if ([...furnacePrefixes].some((prefix) => file.startsWith(prefix))) {
+                warn('This file is managed by Furnace. Run "fireforge furnace apply" to restore it.');
+            }
+        }
+        catch {
+            // Furnace config may not exist — skip silently
+        }
         outro('File restored to original state');
     }
     catch (error) {
@@ -76,7 +88,7 @@ export function registerDiscard(program, { getProjectRoot, withErrorHandling })
         .command('discard <file>')
         .description('Discard changes to a specific file (deletes untracked files)')
         .option('--dry-run', 'Show what would be discarded without doing it')
-        .option('--force', 'Skip confirmation prompt')
+        .option('-y, --yes', 'Skip confirmation prompt')
         .action(withErrorHandling(async (file, options) => {
         await discardCommand(getProjectRoot(), file, pickDefined(options));
     }));

package/dist/src/commands/doctor-furnace.d.ts

@@ -0,0 +1,8 @@
+import type { DoctorCheckDefinition } from './doctor.js';
+/**
+ * The ordered furnace check group. Exported as an array so `doctor.ts`
+ * can splice it into the main registry at the right position. The order
+ * here matters: `Furnace configuration` must run before the consumers
+ * that read `ctx.furnaceConfig`.
+ */
+export declare const FURNACE_DOCTOR_CHECKS: readonly DoctorCheckDefinition[];