@zq-silk/yui 0.2.0 → 0.4.2

package/dist/tmux/commandExecutor.js

@@ -1,4 +1,5 @@
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+const ASYNC_TIMEOUT_KILL_GRACE_MS = 100;
 export class CommandExecutionError extends Error {
     code;
     exitStatus;
@@ -13,7 +14,12 @@ export class CommandExecutionError extends Error {
 }
 export class NodeCommandExecutor {
     run(command, args, options = {}) {
-        const common = options.timeoutMs === undefined ? {} : { timeout: options.timeoutMs };
+        const common = {
+            ...(options.timeoutMs === undefined ? {} : { timeout: options.timeoutMs }),
+            ...(options.environment === undefined
+                ? {}
+                : { env: { ...process.env, ...options.environment } })
+        };
         const result = options.inheritStdio === true
             ? spawnSync(command, args, { ...common, stdio: "inherit" })
             : spawnSync(command, args, {
@@ -26,6 +32,73 @@ export class NodeCommandExecutor {
         }
         return options.inheritStdio === true ? "" : String(result.stdout ?? "");
     }
+    runAsync(command, args, options = {}) {
+        return new Promise((resolve, reject) => {
+            const inheritStdio = options.inheritStdio === true;
+            const child = spawn(command, args, {
+                ...(options.environment === undefined
+                    ? {}
+                    : { env: { ...process.env, ...options.environment } }),
+                stdio: inheritStdio ? "inherit" : ["ignore", "pipe", "pipe"]
+            });
+            const stdout = [];
+            const stderr = [];
+            let spawnError;
+            let timedOut = false;
+            let settled = false;
+            let killTimer;
+            const timer = options.timeoutMs === undefined
+                ? undefined
+                : setTimeout(() => {
+                    if (settled)
+                        return;
+                    timedOut = true;
+                    child.kill("SIGTERM");
+                    killTimer = setTimeout(() => {
+                        child.kill("SIGKILL");
+                    }, ASYNC_TIMEOUT_KILL_GRACE_MS);
+                    killTimer.unref();
+                    child.stdout?.destroy();
+                    child.stderr?.destroy();
+                    settled = true;
+                    reject(stableCommandExecutionError({
+                        code: "ETIMEDOUT",
+                        stderr: Buffer.concat(stderr).toString("utf8")
+                    }));
+                }, options.timeoutMs);
+            timer?.unref();
+            child.stdout?.on("data", (chunk) => {
+                stdout.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            child.once("error", (error) => {
+                spawnError = error;
+            });
+            child.once("close", (status, signal) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                if (killTimer !== undefined)
+                    clearTimeout(killTimer);
+                const capturedStderr = Buffer.concat(stderr).toString("utf8");
+                if (spawnError !== undefined || timedOut || status !== 0) {
+                    reject(stableCommandExecutionError({
+                        ...(spawnError === undefined ? {} : { error: spawnError }),
+                        ...(timedOut ? { code: "ETIMEDOUT" } : {}),
+                        status,
+                        signal,
+                        stderr: capturedStderr
+                    }));
+                    return;
+                }
+                resolve(inheritStdio ? "" : Buffer.concat(stdout).toString("utf8"));
+            });
+        });
+    }
 }
 function stableCommandExecutionError(error) {
     const details = errorDetails(error);