runtimeuse 0.2.0 → 0.3.0

package/src/command-handler.test.ts

@@ -14,23 +14,23 @@ vi.mock("fs", async () => {
   };
 });
 
-let execFileCallback: Function;
-let execFileChild: any;
+let execCallback: Function;
+let execChild: any;
 
 vi.mock("node:child_process", () => ({
-  execFile: vi.fn((_cmd: string, _opts: any, cb: Function) => {
-    execFileCallback = cb;
-    execFileChild = {
+  exec: vi.fn((_cmd: string, _opts: any, cb: Function) => {
+    execCallback = cb;
+    execChild = {
       on: vi.fn(),
       stdout: { on: vi.fn() },
       stderr: { on: vi.fn() },
     };
-    return execFileChild;
+    return execChild;
   }),
 }));
 
 import fs from "fs";
-import { execFile } from "node:child_process";
+import { exec } from "node:child_process";
 import CommandHandler from "./command-handler.js";
 import type { Command } from "./types.js";
 
@@ -40,40 +40,19 @@ const mockLogger: Logger = {
   debug: vi.fn(),
 };
 
-function createStreams() {
-  const stdoutChunks: string[] = [];
-  const stderrChunks: string[] = [];
-
-  const stdoutStream = new Writable({
-    write(chunk, _enc, cb) {
-      stdoutChunks.push(chunk.toString());
-      cb();
-    },
-  });
-
-  const stderrStream = new Writable({
-    write(chunk, _enc, cb) {
-      stderrChunks.push(chunk.toString());
-      cb();
-    },
-  });
-
-  return { stdoutStream, stderrStream, stdoutChunks, stderrChunks };
-}
-
 function createHandler(
   command: Command,
-  stdoutStream: Writable,
-  stderrStream: Writable,
   abortController = new AbortController(),
+  onStdout?: (stdout: string) => void,
+  onStderr?: (stderr: string) => void,
 ) {
-  return new CommandHandler(
+  return new CommandHandler({
     command,
-    mockLogger,
-    stdoutStream,
-    stderrStream,
+    logger: mockLogger,
     abortController,
-  );
+    onStdout,
+    onStderr,
+  });
 }
 
 describe("CommandHandler", () => {
@@ -84,17 +63,12 @@ describe("CommandHandler", () => {
   describe("directory creation", () => {
     it("creates cwd directory when it does not exist", async () => {
       vi.mocked(fs.existsSync).mockReturnValueOnce(false);
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "echo", cwd: "/tmp/test-dir" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "echo", cwd: "/tmp/test-dir" });
 
       const promise = handler.execute();
 
-      execFileCallback(null, "ok", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "ok", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
@@ -108,17 +82,12 @@ describe("CommandHandler", () => {
 
     it("does not create cwd directory when it already exists", async () => {
       vi.mocked(fs.existsSync).mockReturnValueOnce(true);
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "echo", cwd: "/tmp/existing" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "echo", cwd: "/tmp/existing" });
 
       const promise = handler.execute();
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
@@ -129,17 +98,12 @@ describe("CommandHandler", () => {
     });
 
     it("skips directory creation when cwd is not specified", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "echo" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "echo" });
 
       const promise = handler.execute();
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
@@ -152,17 +116,16 @@ describe("CommandHandler", () => {
   });
 
   describe("command execution", () => {
-    it("calls execFile with the right command, cwd, and env", () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "ls", cwd: "/work", env: { FOO: "bar" } },
-        stdoutStream,
-        stderrStream,
-      );
+    it("calls exec with the right command, cwd, and env", () => {
+      const handler = createHandler({
+        command: "ls",
+        cwd: "/work",
+        env: { FOO: "bar" },
+      });
 
       handler.execute();
 
-      expect(execFile).toHaveBeenCalledWith(
+      expect(exec).toHaveBeenCalledWith(
         "ls",
         expect.objectContaining({
           cwd: "/work",
@@ -173,35 +136,24 @@ describe("CommandHandler", () => {
     });
 
     it("uses process.cwd() when cwd is not specified", () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "pwd" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "pwd" });
 
       handler.execute();
 
-      expect(execFile).toHaveBeenCalledWith(
+      expect(exec).toHaveBeenCalledWith(
         "pwd",
         expect.objectContaining({ cwd: process.cwd() }),
         expect.any(Function),
       );
     });
 
-    it("passes abort signal to execFile", () => {
+    it("passes abort signal to exec", () => {
       const ac = new AbortController();
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "sleep" },
-        stdoutStream,
-        stderrStream,
-        ac,
-      );
+      const handler = createHandler({ command: "sleep" }, ac);
 
       handler.execute();
 
-      expect(execFile).toHaveBeenCalledWith(
+      expect(exec).toHaveBeenCalledWith(
         "sleep",
         expect.objectContaining({ signal: ac.signal }),
         expect.any(Function),
@@ -211,17 +163,12 @@ describe("CommandHandler", () => {
 
   describe("exit handling", () => {
     it("resolves with exitCode 0 on successful close", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "true" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "true" });
 
       const promise = handler.execute();
 
-      execFileCallback(null, "output", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "output", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
@@ -231,17 +178,12 @@ describe("CommandHandler", () => {
     });
 
     it("resolves with exitCode 1 on close with code 1", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "false" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "false" });
 
       const promise = handler.execute();
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(1);
@@ -251,17 +193,12 @@ describe("CommandHandler", () => {
     });
 
     it("resolves with exitCode 1 and error when callback reports code 1", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "failing" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "failing" });
 
       const promise = handler.execute();
 
       const err = Object.assign(new Error("exit 1"), { code: 1 });
-      execFileCallback(err, "", "some error");
+      execCallback(err, "", "some error");
 
       const result = await promise;
       expect(result.exitCode).toBe(1);
@@ -269,17 +206,12 @@ describe("CommandHandler", () => {
     });
 
     it("rejects with non-0/1 exit codes from close event", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "segfault" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "segfault" });
 
       const promise = handler.execute();
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(139);
@@ -288,17 +220,12 @@ describe("CommandHandler", () => {
     });
 
     it("rejects when callback reports a non-1 error code", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
-      const handler = createHandler(
-        { command: "crash" },
-        stdoutStream,
-        stderrStream,
-      );
+      const handler = createHandler({ command: "crash" });
 
       const promise = handler.execute();
 
       const err = Object.assign(new Error("killed"), { code: 137 });
-      execFileCallback(err, "", "");
+      execCallback(err, "", "");
 
       await expect(promise).rejects.toMatchObject({ exitCode: 137 });
     });
@@ -306,151 +233,153 @@ describe("CommandHandler", () => {
 
   describe("stream output", () => {
     it("writes stdout to the stdout stream", async () => {
-      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const onStdout = vi.fn();
       const handler = createHandler(
         { command: "echo" },
-        stdoutStream,
-        stderrStream,
+        new AbortController(),
+        onStdout,
       );
 
       const promise = handler.execute();
 
-      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+      const stdoutDataHandler = execChild.stdout.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stdoutDataHandler("hello world");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stdoutChunks).toContain("hello world");
+      expect(onStdout).toHaveBeenCalledWith("hello world");
     });
 
     it("writes stderr to the stderr stream", async () => {
-      const { stdoutStream, stderrStream, stderrChunks } = createStreams();
+      const onStderr = vi.fn();
       const handler = createHandler(
         { command: "warn" },
-        stdoutStream,
-        stderrStream,
+        new AbortController(),
+        undefined,
+        onStderr,
       );
 
       const promise = handler.execute();
 
-      const stderrDataHandler = execFileChild.stderr.on.mock.calls.find(
+      const stderrDataHandler = execChild.stderr.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stderrDataHandler("warning message");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stderrChunks).toContain("warning message");
+      expect(onStderr).toHaveBeenCalledWith("warning message");
     });
 
     it("redacts secrets from stdout", async () => {
-      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const onStdout = vi.fn();
       const handler = createHandler(
-        { command: "echo", env: { API_KEY: "s3cret" } },
-        stdoutStream,
-        stderrStream,
+        {
+          command: "echo",
+          env: { API_KEY: "s3cret" },
+        },
+        new AbortController(),
+        onStdout,
       );
 
       const promise = handler.execute();
 
-      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+      const stdoutDataHandler = execChild.stdout.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stdoutDataHandler("token is s3cret ok");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stdoutChunks).toEqual(["token is [REDACTED] ok"]);
+      expect(onStdout).toHaveBeenCalledWith("token is [REDACTED] ok");
     });
 
     it("redacts secrets from stderr", async () => {
-      const { stdoutStream, stderrStream, stderrChunks } = createStreams();
+      const onStderr = vi.fn();
       const handler = createHandler(
         { command: "warn", env: { PASSWORD: "hunter2" } },
-        stdoutStream,
-        stderrStream,
+        new AbortController(),
+        undefined,
+        onStderr,
       );
 
       const promise = handler.execute();
 
-      const stderrDataHandler = execFileChild.stderr.on.mock.calls.find(
+      const stderrDataHandler = execChild.stderr.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stderrDataHandler("error: hunter2 leaked");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stderrChunks).toEqual(["error: [REDACTED] leaked"]);
+      expect(onStderr).toHaveBeenCalledWith("error: [REDACTED] leaked");
     });
 
     it("redacts multiple env secrets from output", async () => {
-      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const onStdout = vi.fn();
       const handler = createHandler(
         { command: "echo", env: { KEY: "aaa", TOKEN: "bbb" } },
-        stdoutStream,
-        stderrStream,
+        new AbortController(),
+        onStdout,
       );
 
       const promise = handler.execute();
 
-      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+      const stdoutDataHandler = execChild.stdout.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stdoutDataHandler("aaa and bbb");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stdoutChunks).toEqual(["[REDACTED] and [REDACTED]"]);
+      expect(onStdout).toHaveBeenCalledWith("[REDACTED] and [REDACTED]");
     });
 
     it("passes redacted data to onStdout callback", async () => {
-      const { stdoutStream, stderrStream } = createStreams();
       const onStdout = vi.fn();
-      const handler = new CommandHandler(
-        { command: "echo", env: { SECRET: "xyz" } },
-        mockLogger,
-        stdoutStream,
-        stderrStream,
-        new AbortController(),
-        onStdout,
-      );
+      const handler = new CommandHandler({
+        command: { command: "echo", env: { SECRET: "xyz" } },
+        logger: mockLogger,
+        abortController: new AbortController(),
+        onStdout: onStdout,
+      });
 
       const promise = handler.execute();
 
-      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+      const stdoutDataHandler = execChild.stdout.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stdoutDataHandler("value=xyz");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
@@ -460,48 +389,48 @@ describe("CommandHandler", () => {
     });
 
     it("does not redact when command has no env", async () => {
-      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const onStdout = vi.fn();
       const handler = createHandler(
         { command: "echo" },
-        stdoutStream,
-        stderrStream,
+        new AbortController(),
+        onStdout,
       );
 
       const promise = handler.execute();
 
-      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+      const stdoutDataHandler = execChild.stdout.on.mock.calls.find(
         (c: unknown[]) => c[0] === "data",
       )[1];
       stdoutDataHandler("nothing secret here");
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stdoutChunks).toEqual(["nothing secret here"]);
+      expect(onStdout).toHaveBeenCalledWith("nothing secret here");
     });
 
     it("does not write empty stdout", async () => {
-      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const onStdout = vi.fn();
       const handler = createHandler(
         { command: "silent" },
-        stdoutStream,
-        stderrStream,
+        new AbortController(),
+        onStdout,
       );
 
       const promise = handler.execute();
 
-      execFileCallback(null, "", "");
-      const closeHandler = execFileChild.on.mock.calls.find(
+      execCallback(null, "", "");
+      const closeHandler = execChild.on.mock.calls.find(
         (c: unknown[]) => c[0] === "close",
       )[1];
       closeHandler(0);
 
       await promise;
-      expect(stdoutChunks).toHaveLength(0);
+      expect(onStdout).not.toHaveBeenCalled();
     });
   });
 });

package/src/command-handler.ts

@@ -1,5 +1,4 @@
-import { Writable } from "node:stream";
-import { execFile, ExecFileException } from "node:child_process";
+import { exec, ExecFileException } from "node:child_process";
 import fs from "fs";
 import type { Logger } from "./logger.js";
 import type { Command } from "./types.js";
@@ -9,30 +8,26 @@ export interface CommandResult {
   exitCode: number;
   error?: ExecFileException;
 }
+
+export interface CommandHandlerOptions {
+  command: Command;
+  logger: Logger;
+  abortController: AbortController;
+  onStdout?: (stdout: string) => void;
+  onStderr?: (stderr: string) => void;
+}
 class CommandHandler {
   private readonly command: Command;
   private readonly logger: Logger;
-  private readonly stdoutStream: Writable;
-  private readonly stderrStream: Writable;
   private readonly onStdout?: (stdout: string) => void;
   private readonly onStderr?: (stderr: string) => void;
   private readonly abortController: AbortController;
-  constructor(
-    command: Command,
-    logger: Logger,
-    stdoutStream: Writable,
-    stderrStream: Writable,
-    abortController: AbortController,
-    onStdout?: (stdout: string) => void,
-    onStderr?: (stderr: string) => void,
-  ) {
-    this.command = command;
-    this.logger = logger;
-    this.stdoutStream = stdoutStream;
-    this.stderrStream = stderrStream;
-    this.abortController = abortController;
-    this.onStdout = onStdout;
-    this.onStderr = onStderr;
+  constructor(options: CommandHandlerOptions) {
+    this.command = options.command;
+    this.logger = options.logger;
+    this.abortController = options.abortController;
+    this.onStdout = options.onStdout;
+    this.onStderr = options.onStderr;
   }
 
   private redactSecrets(data: string): string {
@@ -46,7 +41,7 @@ class CommandHandler {
       }
     }
     return new Promise((resolve, reject) => {
-      const result = execFile(
+      const result = exec(
         this.command.command,
         {
           cwd: this.command.cwd ?? process.cwd(),
@@ -56,7 +51,7 @@ class CommandHandler {
         (error, stdout, stderr) => {
           if (error) {
             if (error.code === 1) {
-              return resolve({ exitCode: 1, error });
+              return resolve({ exitCode: error.code as number, error });
             }
             this.logger.error(
               "Error executing command:",
@@ -69,12 +64,10 @@ class CommandHandler {
 
       result.stdout?.on("data", (data) => {
         const redactedData = this.redactSecrets(data);
-        this.stdoutStream.write(redactedData);
         this.onStdout?.(redactedData);
       });
       result.stderr?.on("data", (data) => {
         const redactedData = this.redactSecrets(data);
-        this.stderrStream.write(redactedData);
         this.onStderr?.(redactedData);
       });
       result.on("exit", (code) => {
@@ -90,7 +83,7 @@ class CommandHandler {
 
       result.on("close", (code) => {
         if (code === 0 || code === 1) {
-          this.logger.log("Command exited with code:", code);
+          this.logger.log("Command closed with code:", code);
           return resolve({ exitCode: code });
         }
         return reject({ exitCode: code });

package/src/index.ts

@@ -42,7 +42,6 @@ export type {
   ArtifactUploadRequestMessage,
   ArtifactUploadResponseMessage,
   ErrorMessage,
-  StreamEndMessage,
   Command,
   RuntimeEnvironmentDownloadable,
 } from "./types.js";
@@ -53,7 +52,4 @@ export { createLogger, defaultLogger } from "./logger.js";
 export type { Logger } from "./logger.js";
 
 // Constants
-export {
-  DEFAULT_ARTIFACTS_DIR,
-  DEFAULT_ARTIFACT_IGNORE,
-} from "./constants.js";
+export { DEFAULT_ARTIFACTS_DIR, DEFAULT_ARTIFACT_IGNORE } from "./constants.js";