@hominis/fireforge 0.19.6 → 0.20.0

package/dist/src/core/file-lock.js

@@ -35,8 +35,8 @@ function isProcessAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        return getNodeErrorCode(error) !== 'ESRCH';
     }
 }
 async function removeIfStaleLock(lockPath, staleMs, onStaleLockMessage) {

package/dist/src/core/firefox-cache.d.ts

@@ -14,7 +14,7 @@ export declare function sha256File(filePath: string): Promise<string>;
  * @param cacheDir - Cache directory
  * @param onProgress - Optional progress callback
  */
-export declare function ensureCachedArchive(archive: ResolvedArchive, cacheDir: string, onProgress?: ProgressCallback): Promise<void>;
+export declare function ensureCachedArchive(archive: ResolvedArchive, cacheDir: string, onProgress?: ProgressCallback, expectedSha256?: string): Promise<void>;
 /**
  * Removes cached tarball, metadata, and partial download files for an archive.
  * @param archive - Resolved archive descriptor

package/dist/src/core/firefox-cache.js

@@ -7,9 +7,11 @@ import { createReadStream } from 'node:fs';
 import { rename } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
+import { DownloadError } from '../errors/download.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readJson, removeFile, writeJson } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
+import { createSiblingLockPath, withFileLock } from './file-lock.js';
 import { validateArchiveMetadata } from './firefox-archive.js';
 import { downloadFile } from './firefox-download.js';
 /**
@@ -28,12 +30,24 @@ export async function sha256File(filePath) {
  * @param cacheDir - Cache directory
  * @param onProgress - Optional progress callback
  */
-export async function ensureCachedArchive(archive, cacheDir, onProgress) {
-    if (await validateCachedArchive(archive, cacheDir)) {
-        return;
-    }
-    await invalidateArchiveCache(archive, cacheDir);
-    await downloadToCache(archive, cacheDir, onProgress);
+export async function ensureCachedArchive(archive, cacheDir, onProgress, expectedSha256) {
+    const lockPath = createSiblingLockPath(join(cacheDir, archive.filename), '.fireforge-cache.lock');
+    await withFileLock(lockPath, async () => {
+        if (await validateCachedArchive(archive, cacheDir, expectedSha256)) {
+            return;
+        }
+        if (await cacheEntryExists(archive, cacheDir)) {
+            await invalidateArchiveCache(archive, cacheDir);
+        }
+        else {
+            await removeArchivePartFiles(archive, cacheDir);
+        }
+        await downloadToCache(archive, cacheDir, onProgress, expectedSha256);
+    });
+}
+async function cacheEntryExists(archive, cacheDir) {
+    return ((await pathExists(join(cacheDir, archive.filename))) ||
+        (await pathExists(join(cacheDir, archive.metadataFilename))));
 }
 /**
  * Validates a cached archive using sidecar metadata and SHA-256 checksum.
@@ -41,7 +55,7 @@ export async function ensureCachedArchive(archive, cacheDir, onProgress) {
  * @param cacheDir - Cache directory
  * @returns True if the cache entry is valid
  */
-async function validateCachedArchive(archive, cacheDir) {
+async function validateCachedArchive(archive, cacheDir, expectedSha256) {
     const tarballPath = join(cacheDir, archive.filename);
     const metadataPath = join(cacheDir, archive.metadataFilename);
     if (!(await pathExists(tarballPath)) || !(await pathExists(metadataPath))) {
@@ -61,9 +75,12 @@ async function validateCachedArchive(archive, cacheDir) {
                 return false;
             }
         }
-        if (metadata.sha256) {
+        if (expectedSha256 || metadata.sha256) {
             const actualHash = await sha256File(tarballPath);
-            if (actualHash !== metadata.sha256) {
+            if (expectedSha256 && actualHash !== expectedSha256) {
+                return false;
+            }
+            if (metadata.sha256 && actualHash !== metadata.sha256) {
                 return false;
             }
         }
@@ -80,16 +97,21 @@ async function validateCachedArchive(archive, cacheDir) {
  * @param cacheDir - Cache directory
  * @param onProgress - Optional progress callback
  */
-async function downloadToCache(archive, cacheDir, onProgress) {
+async function downloadToCache(archive, cacheDir, onProgress, expectedSha256) {
     const tarballPath = join(cacheDir, archive.filename);
     // Use a unique .part path so concurrent downloads for the same archive
     // do not clobber each other's partial files.
     const partPath = `${tarballPath}.part-${randomUUID()}`;
     const metadataPath = join(cacheDir, archive.metadataFilename);
+    let promotedTarball = false;
     try {
         const contentLength = await downloadFile(archive.url, partPath, onProgress);
         await rename(partPath, tarballPath);
+        promotedTarball = true;
         const sha256 = await sha256File(tarballPath);
+        if (expectedSha256 && sha256 !== expectedSha256) {
+            throw new DownloadError(`Downloaded archive SHA-256 mismatch: expected ${expectedSha256}, got ${sha256}`, archive.url);
+        }
         await writeJson(metadataPath, {
             requestedVersion: archive.requestedVersion,
             product: archive.product,
@@ -102,8 +124,10 @@ async function downloadToCache(archive, cacheDir, onProgress) {
     }
     catch (error) {
         await removeFile(partPath);
-        await removeFile(tarballPath);
-        await removeFile(metadataPath);
+        if (promotedTarball) {
+            await removeFile(tarballPath);
+            await removeFile(metadataPath);
+        }
         throw error;
     }
 }
@@ -115,8 +139,11 @@ async function downloadToCache(archive, cacheDir, onProgress) {
 export async function invalidateArchiveCache(archive, cacheDir) {
     const tarballPath = join(cacheDir, archive.filename);
     const metadataPath = join(cacheDir, archive.metadataFilename);
-    // Clean up any partial download files (may have unique suffixes from
-    // concurrent download attempts).
+    await removeArchivePartFiles(archive, cacheDir);
+    await removeFile(tarballPath);
+    await removeFile(metadataPath);
+}
+async function removeArchivePartFiles(archive, cacheDir) {
     const partPrefix = `${archive.filename}.part`;
     try {
         const { readdir } = await import('node:fs/promises');
@@ -125,10 +152,9 @@ export async function invalidateArchiveCache(archive, cacheDir) {
             .filter((name) => name.startsWith(partPrefix))
             .map((name) => removeFile(join(cacheDir, name))));
     }
-    catch {
+    catch (error) {
+        void error;
         // Cache dir may not exist yet — that's fine.
     }
-    await removeFile(tarballPath);
-    await removeFile(metadataPath);
 }
 //# sourceMappingURL=firefox-cache.js.map

package/dist/src/core/firefox-download.js

@@ -73,20 +73,28 @@ export async function fetchWithRetry(url) {
  */
 function createStallDetector(url, timeoutMs = DOWNLOAD_STALL_TIMEOUT_MS) {
     let timer;
+    const clearTimer = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
     const detector = new Transform({
         transform(chunk, _encoding, callback) {
-            if (timer !== undefined)
-                clearTimeout(timer);
+            clearTimer();
             timer = setTimeout(() => {
                 detector.destroy(new DownloadError(`Download stalled: no data received for ${Math.round(timeoutMs / 1000)} seconds`, url));
             }, timeoutMs);
             callback(null, chunk);
         },
         flush(callback) {
-            if (timer !== undefined)
-                clearTimeout(timer);
+            clearTimer();
             callback();
         },
+        destroy(error, callback) {
+            clearTimer();
+            callback(error);
+        },
     });
     // Start the initial timer (covers the case where the first chunk never arrives).
     timer = setTimeout(() => {

package/dist/src/core/firefox.d.ts

@@ -45,4 +45,4 @@ export type FirefoxSourcePhaseCallback = (phase: FirefoxSourcePhase) => void;
  *   between phases (`'download'` → `'extract'`). Fires exactly once per
  *   phase even if the cached archive path skips the wire entirely.
  */
-export declare function downloadFirefoxSource(version: string, product: FirefoxProduct, destDir: string, cacheDir: string, onProgress?: ProgressCallback, onPhase?: FirefoxSourcePhaseCallback): Promise<void>;
+export declare function downloadFirefoxSource(version: string, product: FirefoxProduct, destDir: string, cacheDir: string, onProgress?: ProgressCallback, onPhase?: FirefoxSourcePhaseCallback, expectedSha256?: string): Promise<void>;

package/dist/src/core/firefox.js

@@ -44,13 +44,13 @@ export function getTarballFilename(version, product = 'firefox') {
  *   between phases (`'download'` → `'extract'`). Fires exactly once per
  *   phase even if the cached archive path skips the wire entirely.
  */
-export async function downloadFirefoxSource(version, product, destDir, cacheDir, onProgress, onPhase) {
+export async function downloadFirefoxSource(version, product, destDir, cacheDir, onProgress, onPhase, expectedSha256) {
     const archive = resolveArchive(version, product);
     const tarballPath = join(cacheDir, archive.filename);
     // Ensure cache directory exists
     await ensureDir(cacheDir);
     onPhase?.('download');
-    await ensureCachedArchive(archive, cacheDir, onProgress);
+    await ensureCachedArchive(archive, cacheDir, onProgress, expectedSha256);
     // Extract to a unique temporary directory so concurrent downloads for
     // the same destination do not clobber each other.
     onPhase?.('extract');

package/dist/src/core/furnace-refresh.js

@@ -17,6 +17,19 @@ import { readText, writeText } from '../utils/fs.js';
 import { exec } from '../utils/process.js';
 import { ensureGit } from './git-base.js';
 import { getFileContentAtRef } from './git-file-ops.js';
+function isFatalMergeStderr(stderr) {
+    return /(?:^|\n)\s*(?:fatal|error):/i.test(stderr);
+}
+function classifyMergeFileResult(result) {
+    if (result.exitCode === 0 && !isFatalMergeStderr(result.stderr)) {
+        return 0;
+    }
+    if (result.exitCode >= 1 && result.exitCode <= 127 && !isFatalMergeStderr(result.stderr)) {
+        return result.exitCode;
+    }
+    const detail = result.stderr.trim() || `exit code ${result.exitCode}`;
+    throw new FurnaceError(`git merge-file failed: ${detail}`);
+}
 /**
  * Performs a three-way merge on a single file.
  *
@@ -40,7 +53,8 @@ async function threeWayMergeFile(base, ours, theirs, label, strategy) {
         await writeText(tempOurs, ours);
         await writeText(tempTheirs, theirs);
         // git merge-file writes the result to the first file (ours) in-place.
-        // Exit code 0 = clean merge, >0 = number of conflicts, <0 = error.
+        // Exit code 0 = clean merge, 1..127 = conflict count, shell-exposed
+        // fatal errors typically arrive as >=128 (for example, 255).
         const mergeArgs = [
             'merge-file',
             ...(strategy ? [`--${strategy}`] : []),
@@ -55,11 +69,8 @@ async function threeWayMergeFile(base, ours, theirs, label, strategy) {
             tempTheirs,
         ];
         const result = await exec('git', mergeArgs);
+        const conflicts = classifyMergeFileResult(result);
         const merged = await readText(tempOurs);
-        const conflicts = result.exitCode > 0 ? result.exitCode : 0;
-        if (result.exitCode < 0) {
-            throw new FurnaceError(`git merge-file failed: ${result.stderr}`);
-        }
         return { merged, conflicts };
     }
     finally {

package/dist/src/core/patch-lint-imports.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detects relative JS imports while avoiding comment/template false positives.
+ * Falls back to stripped-text matching for legacy chrome scripts Acorn cannot parse.
+ */
+export declare function hasRelativeImport(content: string): boolean;

package/dist/src/core/patch-lint-imports.js

@@ -0,0 +1,68 @@
+import { stripJsComments } from '../utils/regex.js';
+import { parseModule, parseScript, walkAST } from './ast-utils.js';
+const RELATIVE_IMPORT_FALLBACK_PATTERN = /(?:\bimport\s*(?:\(\s*)?(?:[\s\S]*?\bfrom\s*)?|\bexport\s+(?:[\s\S]*?\bfrom\s*)?|(?:ChromeUtils\.import(?:ESModule)?|Cu\.import)\s*\(\s*)["'](?:\.\.?\/)/m;
+function literalString(node) {
+    if (!node || node.type !== 'Literal')
+        return undefined;
+    return typeof node.value === 'string' ? node.value : undefined;
+}
+function isRelativeSpecifier(value) {
+    return value !== undefined && (value.startsWith('./') || value.startsWith('../'));
+}
+function isChromeImportCall(node) {
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression' || callee.computed)
+        return false;
+    if (callee.object.type !== 'Identifier' || callee.property.type !== 'Identifier')
+        return false;
+    if (callee.object.name === 'Cu') {
+        return callee.property.name === 'import';
+    }
+    return (callee.object.name === 'ChromeUtils' &&
+        (callee.property.name === 'import' || callee.property.name === 'importESModule'));
+}
+function astHasRelativeImport(content, sourceType) {
+    const ast = sourceType === 'module' ? parseModule(content) : parseScript(content);
+    let found = false;
+    walkAST(ast, {
+        enter(node) {
+            if (found) {
+                this.skip();
+                return;
+            }
+            if (node.type === 'ImportDeclaration') {
+                found = isRelativeSpecifier(literalString(node.source));
+            }
+            else if (node.type === 'ImportExpression') {
+                found = isRelativeSpecifier(literalString(node.source));
+            }
+            else if (node.type === 'ExportNamedDeclaration' || node.type === 'ExportAllDeclaration') {
+                found = isRelativeSpecifier(literalString(node.source));
+            }
+            else if (node.type === 'CallExpression' && isChromeImportCall(node)) {
+                found = isRelativeSpecifier(literalString(node.arguments[0]));
+            }
+        },
+    });
+    return found;
+}
+/**
+ * Detects relative JS imports while avoiding comment/template false positives.
+ * Falls back to stripped-text matching for legacy chrome scripts Acorn cannot parse.
+ */
+export function hasRelativeImport(content) {
+    try {
+        return astHasRelativeImport(content, 'module');
+    }
+    catch (moduleError) {
+        void moduleError;
+    }
+    try {
+        return astHasRelativeImport(content, 'script');
+    }
+    catch (scriptError) {
+        void scriptError;
+    }
+    return RELATIVE_IMPORT_FALLBACK_PATTERN.test(stripJsComments(content));
+}
+//# sourceMappingURL=patch-lint-imports.js.map

package/dist/src/core/patch-lint.js

@@ -10,6 +10,7 @@ import { invokePatchLintCheckJs } from './patch-lint-checkjs.js';
 import { lintChromeScriptJsDocForFile } from './patch-lint-chrome-jsdoc.js';
 import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
 import { AGGREGATE_PATCH_FILE } from './patch-lint-diff-tag.js';
+import { hasRelativeImport } from './patch-lint-imports.js';
 import { validateExportJsDoc } from './patch-lint-jsdoc.js';
 import { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';
 // ---------------------------------------------------------------------------
@@ -423,9 +424,7 @@ export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config, pa
         const isSysMjs = file.endsWith('.sys.mjs');
         // 1. Relative import check
         const strippedContent = stripJsComments(content);
-        const relativeImportPattern = /(?:ChromeUtils\.import(?:ESModule)?|Cu\.import)\s*\(\s*["'](?:\.\.?\/)/gm;
-        const esRelativePattern = /\bimport\s+.*?\s+from\s+["'](?:\.\.?\/)/gm;
-        if (relativeImportPattern.test(strippedContent) || esRelativePattern.test(strippedContent)) {
+        if (hasRelativeImport(content)) {
             issues.push({
                 file,
                 check: 'relative-import',

package/dist/src/types/config.d.ts

@@ -10,6 +10,8 @@ export interface FirefoxConfig {
     version: string;
     /** Firefox product type */
     product: FirefoxProduct;
+    /** Optional pinned SHA-256 for the resolved source archive */
+    sha256?: string;
 }
 /**
  * Supported project license SPDX identifiers.

package/dist/src/utils/fs.d.ts

@@ -3,6 +3,11 @@
  * @param path - Path to check
  */
 export declare function pathExists(path: string): Promise<boolean>;
+/**
+ * Checks if a path exists while surfacing permission errors.
+ * @param path - Path to check
+ */
+export declare function pathExistsStrict(path: string): Promise<boolean>;
 /**
  * Ensures a directory exists, creating it recursively if needed.
  * @param path - Directory path to ensure

package/dist/src/utils/fs.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { randomUUID } from 'node:crypto';
-import { access, copyFile as fsCopyFile, mkdir, open, readdir, readFile, rename, rm, statfs, } from 'node:fs/promises';
+import { access, chmod, copyFile as fsCopyFile, mkdir, open, readdir, readFile, rename, rm, stat, statfs, } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 const RETRIABLE_REMOVE_ERRORS = new Set(['ENOTEMPTY', 'EBUSY', 'EPERM']);
 function sleep(ms) {
@@ -22,6 +22,25 @@ export async function pathExists(path) {
         return false;
     }
 }
+/**
+ * Checks if a path exists while surfacing permission errors.
+ * @param path - Path to check
+ */
+export async function pathExistsStrict(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        const code = error instanceof Error && 'code' in error && typeof error.code === 'string'
+            ? error.code
+            : undefined;
+        if (code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
 /**
  * Ensures a directory exists, creating it recursively if needed.
  * @param path - Directory path to ensure
@@ -137,6 +156,18 @@ export async function writeTextIfChanged(path, content) {
  */
 export async function writeFileAtomic(path, content) {
     await ensureParentDir(path);
+    let existingMode;
+    try {
+        existingMode = (await stat(path)).mode;
+    }
+    catch (error) {
+        const code = error instanceof Error && 'code' in error && typeof error.code === 'string'
+            ? error.code
+            : undefined;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+    }
     const tempPath = createAtomicTempPath(path);
     const handle = await open(tempPath, 'w');
     try {
@@ -150,13 +181,35 @@ export async function writeFileAtomic(path, content) {
     }
     await handle.close();
     try {
+        if (existingMode !== undefined) {
+            await chmod(tempPath, existingMode);
+        }
         await rename(tempPath, path);
+        await syncParentDir(path);
     }
     catch (error) {
         await rm(tempPath, { force: true });
         throw error;
     }
 }
+async function syncParentDir(path) {
+    let directoryHandle;
+    try {
+        directoryHandle = await open(dirname(path), 'r');
+        await directoryHandle.sync();
+    }
+    catch (error) {
+        void error;
+    }
+    finally {
+        try {
+            await directoryHandle?.close();
+        }
+        catch (error) {
+            void error;
+        }
+    }
+}
 /**
  * Copies a directory recursively.
  * @param src - Source directory path

package/dist/src/utils/process.js

@@ -367,7 +367,10 @@ export async function findExecutable(name) {
         const result = await exec(command, [name]);
         if (result.exitCode === 0 && result.stdout.trim()) {
             // Return the first line (first match)
-            return result.stdout.trim().split('\n')[0];
+            return result.stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .find((line) => line.length > 0);
         }
         return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.19.6",
+  "version": "0.20.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",