refactor: use Promise.withResolvers() (Node 22+)

Replace new Promise((resolve, reject) => { ... }) with the cleaner
Promise.withResolvers() pattern in background-task-queue.ts (2 sites)
and sh.ts (1 site).

Author: marcoscaceres

utils/background-task-queue.ts

@@ -186,28 +186,28 @@ export class BackgroundTaskQueue<M extends TaskModule> {
       this.worker.stderr.pipe(split2()).on("data", log.onstderr);
 
       try {
-        return await new Promise<RetType>((resolve, reject) => {
-          const listener = (response: Response) => {
-            if (response.id === id) {
-              this.lock.release();
-              this.worker.removeListener("message", listener);
-
-              const { type, result } = response;
-
-              log.setResult(type, result);
-              this.worker.stdout.off("data", log.onstdout);
-              this.worker.stderr.off("data", log.onstderr);
-              log.markTime("finish");
-
-              if (type === "success") {
-                resolve(result as RetType);
-              } else {
-                reject(deserializeError(result));
-              }
+        const { promise, resolve, reject } = Promise.withResolvers<RetType>();
+        const listener = (response: Response) => {
+          if (response.id === id) {
+            this.lock.release();
+            this.worker.removeListener("message", listener);
+
+            const { type, result } = response;
+
+            log.setResult(type, result);
+            this.worker.stdout.off("data", log.onstdout);
+            this.worker.stderr.off("data", log.onstderr);
+            log.markTime("finish");
+
+            if (type === "success") {
+              resolve(result as RetType);
+            } else {
+              reject(deserializeError(result));
             }
-          };
-          this.worker.addListener("message", listener);
-        });
+          }
+        };
+        this.worker.addListener("message", listener);
+        return await promise;
       } finally {
         await log.write();
       }
@@ -224,19 +224,19 @@ export class BackgroundTaskQueue<M extends TaskModule> {
     const msg: OperationRequest = { id, type: "init", modulePath };
     this.worker.postMessage(msg);
 
-    await new Promise<void>((resolve, reject) => {
-      this.worker.once("message", (response: Response) => {
-        if (response.id !== id) {
-          reject(new Error(`Failed to register worker module: ${modulePath}`));
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
+    this.worker.once("message", (response: Response) => {
+      if (response.id !== id) {
+        reject(new Error(`Failed to register worker module: ${modulePath}`));
+      } else {
+        if (response.type === "success") {
+          resolve();
         } else {
-          if (response.type === "success") {
-            resolve();
-          } else {
-            reject(deserializeError(response.result));
-          }
+          reject(deserializeError(response.result));
         }
-      });
+      }
     });
+    await promise;
   }
 
   private generateId() {

utils/sh.ts

@@ -31,34 +31,37 @@ export default async function sh(
   }
 
   try {
-    return await new Promise<string>((resolve, reject) => {
-      let stdout: string[] = [];
-      let stderr: string[] = [];
-      const child = exec(command, {
-        ...execOptions,
-        env: { ...process.env, ...execOptions.env },
-        encoding: "utf-8",
-      });
-      child.stdout!.pipe(split()).on("data", (line: string) => {
-        if (shouldStream) log.out(line);
-        stdout.push(line);
-      });
-      child.stderr!.pipe(split()).on("data", (line: string) => {
-        if (shouldStream) log.err(line);
-        stderr.push(line);
-      });
-      child.on("exit", code => {
-        if (output === "buffer") {
-          if (stdout.length) log.out(stdout.join("\n"));
-          if (stderr.length) log.err(stderr.join("\n"));
-        }
-        if (code === 0) {
-          resolve(stdout.join("\n"));
-        } else {
-          reject({ command, stdout, stderr, code });
-        }
-      });
+    const { promise, resolve, reject } = Promise.withResolvers<string>();
+    let stdout: string[] = [];
+    let stderr: string[] = [];
+    const child = exec(command, {
+      ...execOptions,
+      env: { ...process.env, ...execOptions.env },
+      encoding: "utf-8",
     });
+    child.stdout!.pipe(split()).on("data", (line: string) => {
+      if (shouldStream) log.out(line);
+      stdout.push(line);
+    });
+    child.stderr!.pipe(split()).on("data", (line: string) => {
+      if (shouldStream) log.err(line);
+      stderr.push(line);
+    });
+    child.on("error", err => {
+      reject({ command, stdout, stderr, code: null, error: err });
+    });
+    child.on("close", code => {
+      if (output === "buffer") {
+        if (stdout.length) log.out(stdout.join("\n"));
+        if (stderr.length) log.err(stderr.join("\n"));
+      }
+      if (code === 0) {
+        resolve(stdout.join("\n"));
+      } else {
+        reject({ command, stdout, stderr, code });
+      }
+    });
+    return await promise;
   } finally {
     if (output !== "silent") {
       console.groupEnd();