@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/cli/version.js

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Which FireForge this is: the package's root directory, its version, and the
+ * build identity `--version` reports as `<semver>+g<commit>[.dirty[.<hash>]]`.
+ *
+ * In a git checkout the identity comes from git itself, so a stale build stamp
+ * never wins. An installed package reads `dist/build-info.json`, stamped at
+ * build time. When neither yields an identity the plain version is reported.
+ */
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { invariant } from '../kernel/errors.js';
+import { exists } from '../kernel/fs.js';
+import { readJsonIfExists } from '../kernel/json.js';
+import { run } from '../kernel/process/index.js';
+import { s } from '../kernel/schema.js';
+const PackageManifest = s.object({
+    version: s.string().optional(),
+    bin: s.union(s.string(), s.record(s.string())).optional(),
+    bugs: s.object({ url: s.string().optional() }, { unknownKeys: 'keep' }).optional(),
+}, { unknownKeys: 'keep' });
+const nullable = (schema) => s.union(schema, s.literal(null)).optional();
+const BuildInfo = s.object({
+    shortCommit: nullable(s.string()),
+    dirty: nullable(s.boolean()),
+    dirtyHash: nullable(s.string()),
+}, { unknownKeys: 'keep' });
+let root;
+async function locate() {
+    // Works from the source tree and from the compiled one: the root is the
+    // nearest directory whose package.json provides the `fireforge` executable.
+    for (let current = dirname(fileURLToPath(import.meta.url));; current = dirname(current)) {
+        const manifest = await readJsonIfExists(join(current, 'package.json'), PackageManifest);
+        if (typeof manifest?.bin === 'object' && manifest.bin['fireforge'] !== undefined) {
+            return {
+                path: current,
+                version: manifest.version ?? '0.0.0',
+                issuesUrl: manifest.bugs?.url,
+            };
+        }
+        invariant(current !== dirname(current), 'the fireforge package root exists');
+    }
+}
+/** The directory FireForge is installed in, which holds `templates/`. */
+export async function packageRoot() {
+    root ??= locate();
+    return (await root).path;
+}
+/** The package's semantic version. */
+export async function packageVersion() {
+    root ??= locate();
+    return (await root).version;
+}
+/** Where the package asks for bug reports, when it says. */
+export async function issuesUrl() {
+    root ??= locate();
+    return (await root).issuesUrl;
+}
+/**
+ * Formats a version with its build identity. Every segment stays valid
+ * semver build metadata.
+ *
+ * @param version - The semantic version
+ * @param identity - The build identity, when known
+ */
+export function formatVersion(version, identity) {
+    if (identity === undefined)
+        return version;
+    const base = `${version}+g${identity.shortCommit}`;
+    if (!identity.dirty)
+        return base;
+    return identity.dirtyHash === undefined ? `${base}.dirty` : `${base}.dirty.${identity.dirtyHash}`;
+}
+async function buildIdentity(packagePath) {
+    if (await exists(join(packagePath, '.git'))) {
+        const head = await run('git', ['rev-parse', 'HEAD'], { cwd: packagePath });
+        const commit = head.stdout.trim();
+        if (head.exitCode !== 0 || !/^[0-9a-f]{7,40}$/.test(commit))
+            return undefined;
+        const status = await run('git', ['status', '--porcelain'], { cwd: packagePath });
+        if (status.exitCode !== 0)
+            return undefined;
+        return { shortCommit: commit.slice(0, 12), dirty: status.stdout.length > 0 };
+    }
+    const info = await readJsonIfExists(join(packagePath, 'dist', 'build-info.json'), BuildInfo);
+    if (typeof info?.shortCommit !== 'string' || info.shortCommit === '')
+        return undefined;
+    return {
+        shortCommit: info.shortCommit,
+        dirty: info.dirty === true,
+        ...(typeof info.dirtyHash === 'string' ? { dirtyHash: info.dirtyHash } : {}),
+    };
+}
+/** The string `fireforge --version` prints. Never throws: it degrades to the plain version. */
+export async function cliVersion() {
+    const version = await packageVersion();
+    const identity = await buildIdentity(await packageRoot()).catch(() => undefined);
+    return formatVersion(version, identity);
+}

package/dist/src/commands/bootstrap.js

@@ -1,103 +1,18 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { Command } from 'commander';
-import { getProjectPaths } from '../core/config.js';
-import { assertEngineExists } from '../core/engine-precondition.js';
-import { ensureOriginRemote } from '../core/git.js';
-import { bootstrapWithOutput } from '../core/mach.js';
-import { GeneralError } from '../errors/base.js';
-import { BootstrapError } from '../errors/build.js';
-import { ExitCode } from '../errors/codes.js';
-import { error, info, intro, outro, warn } from '../utils/logger.js';
-import { detectBootstrapIssues, runPostBootstrapChecks, } from './bootstrap-checks.js';
-import { reportDoctorResults } from './doctor.js';
-/** One sentence per detected issue, keyed by the scanner's own tags. */
-const BOOTSTRAP_FAILURE_SENTENCES = {
-    'python-traceback': 'Bootstrap emitted a Python traceback.',
-    'sdk-fetch-403': 'Bootstrap hit an HTTP 403 while fetching dependencies.',
-    'missing-origin-remote': 'Bootstrap expected an "origin" git remote in the Firefox source checkout.',
-};
-/**
- * Builds a human-readable failure message for hard failures (non-zero exit).
- * Used only when mach bootstrap itself reports failure.
- */
-function buildBootstrapFailureMessage(output) {
-    // Delegates detection to the canonical scanner rather than keeping a
-    // second copy of its six regexes. The copies had already disagreed: this
-    // one reported a traceback and a 403 separately, while
-    // `detectBootstrapIssues` collapses them, because a bootstrap traceback
-    // accompanying a 403 is just the stack trace from that HTTP error.
-    const issues = detectBootstrapIssues(output).map((issue) => BOOTSTRAP_FAILURE_SENTENCES[issue]);
-    if (issues.length === 0) {
-        return undefined;
-    }
-    return ('Bootstrap did not complete successfully.\n\n' +
-        `${issues.join('\n')}\n\n` +
-        'Review the bootstrap output above, fix the underlying dependency or source-tree issue, and rerun "fireforge bootstrap".');
-}
-/**
- * Runs the bootstrap command.
- * @param projectRoot - Root directory of the project
- */
-export async function bootstrapCommand(projectRoot) {
-    intro('FireForge Bootstrap');
-    const paths = getProjectPaths(projectRoot);
-    // Check if engine exists
-    await assertEngineExists(paths.engine);
-    // Ensure the engine repo has an "origin" remote so Firefox's bootstrap
-    // scripts don't emit noisy "No such remote" errors.
-    await ensureOriginRemote(paths.engine);
-    info('Installing Firefox build dependencies...');
-    info('This may take a while and require sudo permissions.\n');
-    const result = await bootstrapWithOutput(paths.engine);
-    if (result.exitCode !== 0) {
-        error('Bootstrap failed');
-        const failureMessage = buildBootstrapFailureMessage(`${result.stdout}\n${result.stderr}`);
-        if (failureMessage) {
-            throw new GeneralError(failureMessage);
-        }
-        throw new BootstrapError();
-    }
-    // mach bootstrap may exit 0 even when sub-downloads fail (e.g. HTTP 403).
-    // Instead of guessing from output text, detect what went wrong and run
-    // targeted checks to determine whether the issues are actually actionable.
-    const output = `${result.stdout}\n${result.stderr}`;
-    const issues = detectBootstrapIssues(output);
-    if (issues.length > 0) {
-        const checks = await runPostBootstrapChecks(issues);
-        // Shares one resolver with reportDoctorResults so the two consumers of
-        // this same array cannot drift apart on how a check's severity is
-        // derived.
-        const hasErrors = checks.some((c) => c.severity === 'error');
-        info('');
-        if (hasErrors) {
-            warn('Bootstrap completed with issues:');
-        }
-        else {
-            warn('Bootstrap completed with warnings:');
-        }
-        const checksExitCode = reportDoctorResults(checks);
-        if (hasErrors) {
-            outro('Build dependencies installed with errors');
-            // Propagate the failure (mirroring doctor's exit-code handling)
-            // instead of exiting 0, so CI gating on bootstrap does not proceed to
-            // a build that cannot succeed.
-            return checksExitCode;
-        }
-        outro('Build dependencies installed with warnings');
-        return ExitCode.SUCCESS;
-    }
-    outro('Build dependencies installed successfully!');
-    return ExitCode.SUCCESS;
-}
-/** Registers the bootstrap command on the CLI program. */
-export function registerBootstrap(program, { getProjectRoot, withErrorHandling }) {
-    program
-        .command('bootstrap')
-        .description('Install Firefox build dependencies')
-        .action(withErrorHandling(async () => {
-        const exitCode = await bootstrapCommand(getProjectRoot());
-        if (exitCode !== ExitCode.SUCCESS) {
-            process.exitCode = exitCode;
-        }
-    }));
-}
+import { defineCommand, lockWaitMs } from '../cli/command.js';
+import { bootstrap as runBootstrap } from '../engine/index.js';
+import { withWorkspace } from '../mode/index.js';
+import { loadProject } from '../project/index.js';
+import { workspaceOptions } from './workspace.js';
+export const bootstrap = defineCommand({
+    name: 'bootstrap',
+    summary: 'Install Firefox build dependencies (mach bootstrap)',
+    description: 'Runs mach bootstrap for the browser application. It may prompt and ask for elevated rights.',
+    group: 'Engine',
+    options: { ...workspaceOptions },
+    run: async (ctx, _args, opts) => {
+        const project = await loadProject(ctx.cwd, ctx.env);
+        await withWorkspace(project, { command: 'bootstrap', workspace: opts.workspace, waitMs: lockWaitMs(opts.waitLock) }, runBootstrap);
+        ctx.out.line('Build dependencies are installed.');
+    },
+});