@hominis/fireforge 0.15.6 → 0.15.8

package/dist/src/utils/process.js

@@ -234,6 +234,128 @@ export async function execInheritCapture(command, args, options = {}) {
         });
     });
 }
+/**
+ * Spawns `command` with `args` in its own process group (POSIX), streams
+ * stdout/stderr line-by-line to the caller, enforces a deadline by
+ * SIGTERMing the whole group when it elapses, and returns the captured
+ * output alongside a `timedOut` flag.
+ *
+ * Process-group semantics matter here because `mach run` execs a Python
+ * wrapper that then forks Firefox, which itself spawns content processes.
+ * Sending SIGTERM only to the Python PID leaves an orphan Firefox tree
+ * behind. Running the child as a process-group leader (`detached: true`
+ * on POSIX) and signalling `-pid` routes the kill to every descendant
+ * that inherited the group.
+ *
+ * Windows fallback: `detached: true` does not create an equivalent group
+ * there, so we degrade to `child.kill()` and log a best-effort warning
+ * via the `onStderrLine` callback if the caller wired one.
+ */
+export async function execSmokeRun(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const usesProcessGroup = process.platform !== 'win32';
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // A new process group on POSIX lets us signal the whole descendant
+            // tree at once, which is essential for mach → python → firefox →
+            // content-process chains. On Windows spawn ignores this for our
+            // purposes and we fall back to child.kill below.
+            detached: usesProcessGroup,
+        });
+        const out = createStreamCollector(options.mirror?.stdout);
+        const err = createStreamCollector(options.mirror?.stderr);
+        let stdoutBuffer = '';
+        let stderrBuffer = '';
+        child.stdout.on('data', (data) => {
+            out.onData(data);
+            stdoutBuffer += data.toString();
+            stdoutBuffer = dispatchCompleteLines(stdoutBuffer, options.onStdoutLine);
+        });
+        child.stderr.on('data', (data) => {
+            err.onData(data);
+            stderrBuffer += data.toString();
+            stderrBuffer = dispatchCompleteLines(stderrBuffer, options.onStderrLine);
+        });
+        let timedOut = false;
+        let graceTimer;
+        const signalChildGroup = (signal) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            const targetPid = child.pid;
+            if (targetPid === undefined)
+                return;
+            try {
+                if (usesProcessGroup) {
+                    // Negative PID routes to the process group, killing the Python
+                    // wrapper, the firefox it forked, and every content process
+                    // that inherited the group.
+                    process.kill(-targetPid, signal);
+                }
+                else {
+                    child.kill(signal);
+                }
+            }
+            catch {
+                // Already gone. Nothing to do.
+            }
+        };
+        const deadlineTimer = setTimeout(() => {
+            timedOut = true;
+            signalChildGroup('SIGTERM');
+            graceTimer = setTimeout(() => {
+                signalChildGroup('SIGKILL');
+            }, options.killGraceMs ?? 10000);
+            graceTimer.unref();
+        }, options.smokeTimeoutMs);
+        deadlineTimer.unref();
+        child.on('error', (error) => {
+            clearTimeout(deadlineTimer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            reject(error);
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(deadlineTimer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            // Flush any remaining partial line (child ended without a trailing newline).
+            if (stdoutBuffer.length > 0)
+                options.onStdoutLine?.(stdoutBuffer);
+            if (stderrBuffer.length > 0)
+                options.onStderrLine?.(stderrBuffer);
+            resolve({
+                stdout: out.getText(),
+                stderr: err.getText(),
+                exitCode: exitCodeFromClose(code, signal),
+                timedOut,
+            });
+        });
+    });
+}
+/**
+ * Drains complete newline-terminated lines from `buffer`, dispatching each
+ * trimmed-of-newline line to `cb`. Returns the remaining partial line that
+ * has not yet been terminated — callers should keep accumulating into it.
+ */
+function dispatchCompleteLines(buffer, cb) {
+    if (!cb) {
+        // No listener — still need to collapse accumulated newlines so the
+        // buffer does not grow forever. Keep only the partial-line tail.
+        const lastNewline = buffer.lastIndexOf('\n');
+        if (lastNewline === -1)
+            return buffer;
+        return buffer.slice(lastNewline + 1);
+    }
+    let idx;
+    while ((idx = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, idx).replace(/\r$/, '');
+        buffer = buffer.slice(idx + 1);
+        cb(line);
+    }
+    return buffer;
+}
 /**
  * Finds an executable in the system PATH.
  * @param name - Name of the executable

package/package.json

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