runtimeuse 0.2.0

package/src/command-handler.test.ts

@@ -0,0 +1,507 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Writable } from "node:stream";
+import type { Logger } from "./logger.js";
+
+vi.mock("fs", async () => {
+  const actual = await vi.importActual<typeof import("fs")>("fs");
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+    },
+  };
+});
+
+let execFileCallback: Function;
+let execFileChild: any;
+
+vi.mock("node:child_process", () => ({
+  execFile: vi.fn((_cmd: string, _opts: any, cb: Function) => {
+    execFileCallback = cb;
+    execFileChild = {
+      on: vi.fn(),
+      stdout: { on: vi.fn() },
+      stderr: { on: vi.fn() },
+    };
+    return execFileChild;
+  }),
+}));
+
+import fs from "fs";
+import { execFile } from "node:child_process";
+import CommandHandler from "./command-handler.js";
+import type { Command } from "./types.js";
+
+const mockLogger: Logger = {
+  log: vi.fn(),
+  error: vi.fn(),
+  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(),
+) {
+  return new CommandHandler(
+    command,
+    mockLogger,
+    stdoutStream,
+    stderrStream,
+    abortController,
+  );
+}
+
+describe("CommandHandler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  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 promise = handler.execute();
+
+      execFileCallback(null, "ok", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith("/tmp/test-dir", {
+        recursive: true,
+      });
+    });
+
+    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 promise = handler.execute();
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+    });
+
+    it("skips directory creation when cwd is not specified", async () => {
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "echo" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+
+      expect(fs.existsSync).not.toHaveBeenCalled();
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+    });
+  });
+
+  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,
+      );
+
+      handler.execute();
+
+      expect(execFile).toHaveBeenCalledWith(
+        "ls",
+        expect.objectContaining({
+          cwd: "/work",
+          env: expect.objectContaining({ FOO: "bar" }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it("uses process.cwd() when cwd is not specified", () => {
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "pwd" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      handler.execute();
+
+      expect(execFile).toHaveBeenCalledWith(
+        "pwd",
+        expect.objectContaining({ cwd: process.cwd() }),
+        expect.any(Function),
+      );
+    });
+
+    it("passes abort signal to execFile", () => {
+      const ac = new AbortController();
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "sleep" },
+        stdoutStream,
+        stderrStream,
+        ac,
+      );
+
+      handler.execute();
+
+      expect(execFile).toHaveBeenCalledWith(
+        "sleep",
+        expect.objectContaining({ signal: ac.signal }),
+        expect.any(Function),
+      );
+    });
+  });
+
+  describe("exit handling", () => {
+    it("resolves with exitCode 0 on successful close", async () => {
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "true" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      execFileCallback(null, "output", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      const result = await promise;
+      expect(result).toEqual({ exitCode: 0 });
+    });
+
+    it("resolves with exitCode 1 on close with code 1", async () => {
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "false" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(1);
+
+      const result = await promise;
+      expect(result).toEqual({ exitCode: 1 });
+    });
+
+    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 promise = handler.execute();
+
+      const err = Object.assign(new Error("exit 1"), { code: 1 });
+      execFileCallback(err, "", "some error");
+
+      const result = await promise;
+      expect(result.exitCode).toBe(1);
+      expect(result.error).toBeDefined();
+    });
+
+    it("rejects with non-0/1 exit codes from close event", async () => {
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "segfault" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(139);
+
+      await expect(promise).rejects.toEqual({ exitCode: 139 });
+    });
+
+    it("rejects when callback reports a non-1 error code", async () => {
+      const { stdoutStream, stderrStream } = createStreams();
+      const handler = createHandler(
+        { command: "crash" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const err = Object.assign(new Error("killed"), { code: 137 });
+      execFileCallback(err, "", "");
+
+      await expect(promise).rejects.toMatchObject({ exitCode: 137 });
+    });
+  });
+
+  describe("stream output", () => {
+    it("writes stdout to the stdout stream", async () => {
+      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const handler = createHandler(
+        { command: "echo" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "data",
+      )[1];
+      stdoutDataHandler("hello world");
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stdoutChunks).toContain("hello world");
+    });
+
+    it("writes stderr to the stderr stream", async () => {
+      const { stdoutStream, stderrStream, stderrChunks } = createStreams();
+      const handler = createHandler(
+        { command: "warn" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const stderrDataHandler = execFileChild.stderr.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "data",
+      )[1];
+      stderrDataHandler("warning message");
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stderrChunks).toContain("warning message");
+    });
+
+    it("redacts secrets from stdout", async () => {
+      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const handler = createHandler(
+        { command: "echo", env: { API_KEY: "s3cret" } },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const stdoutDataHandler = execFileChild.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(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stdoutChunks).toEqual(["token is [REDACTED] ok"]);
+    });
+
+    it("redacts secrets from stderr", async () => {
+      const { stdoutStream, stderrStream, stderrChunks } = createStreams();
+      const handler = createHandler(
+        { command: "warn", env: { PASSWORD: "hunter2" } },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const stderrDataHandler = execFileChild.stderr.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "data",
+      )[1];
+      stderrDataHandler("error: hunter2 leaked");
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stderrChunks).toEqual(["error: [REDACTED] leaked"]);
+    });
+
+    it("redacts multiple env secrets from output", async () => {
+      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const handler = createHandler(
+        { command: "echo", env: { KEY: "aaa", TOKEN: "bbb" } },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "data",
+      )[1];
+      stdoutDataHandler("aaa and bbb");
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stdoutChunks).toEqual(["[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 promise = handler.execute();
+
+      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "data",
+      )[1];
+      stdoutDataHandler("value=xyz");
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(onStdout).toHaveBeenCalledWith("value=[REDACTED]");
+    });
+
+    it("does not redact when command has no env", async () => {
+      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const handler = createHandler(
+        { command: "echo" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      const stdoutDataHandler = execFileChild.stdout.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "data",
+      )[1];
+      stdoutDataHandler("nothing secret here");
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stdoutChunks).toEqual(["nothing secret here"]);
+    });
+
+    it("does not write empty stdout", async () => {
+      const { stdoutStream, stderrStream, stdoutChunks } = createStreams();
+      const handler = createHandler(
+        { command: "silent" },
+        stdoutStream,
+        stderrStream,
+      );
+
+      const promise = handler.execute();
+
+      execFileCallback(null, "", "");
+      const closeHandler = execFileChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === "close",
+      )[1];
+      closeHandler(0);
+
+      await promise;
+      expect(stdoutChunks).toHaveLength(0);
+    });
+  });
+});

package/src/command-handler.ts

@@ -0,0 +1,102 @@
+import { Writable } from "node:stream";
+import { execFile, ExecFileException } from "node:child_process";
+import fs from "fs";
+import type { Logger } from "./logger.js";
+import type { Command } from "./types.js";
+import { redactSecrets } from "./utils.js";
+
+export interface CommandResult {
+  exitCode: number;
+  error?: ExecFileException;
+}
+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;
+  }
+
+  private redactSecrets(data: string): string {
+    return redactSecrets(data, Object.values(this.command.env ?? {}));
+  }
+
+  async execute(): Promise<CommandResult> {
+    if (this.command.cwd) {
+      if (!fs.existsSync(this.command.cwd)) {
+        fs.mkdirSync(this.command.cwd, { recursive: true });
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const result = execFile(
+        this.command.command,
+        {
+          cwd: this.command.cwd ?? process.cwd(),
+          env: { ...process.env, ...this.command.env },
+          signal: this.abortController.signal,
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            if (error.code === 1) {
+              return resolve({ exitCode: 1, error });
+            }
+            this.logger.error(
+              "Error executing command:",
+              JSON.stringify(error),
+            );
+            return reject({ exitCode: error.code, error });
+          }
+        },
+      );
+
+      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) => {
+        this.logger.log("Command exited with code:", code);
+      });
+      result.on("error", (error) => {
+        this.logger.error("Command error:", error);
+        return reject({ exitCode: 2, error });
+      });
+      result.on("spawn", () => {
+        this.logger.log("Command spawned:", this.command.command);
+      });
+
+      result.on("close", (code) => {
+        if (code === 0 || code === 1) {
+          this.logger.log("Command exited with code:", code);
+          return resolve({ exitCode: code });
+        }
+        return reject({ exitCode: code });
+      });
+    });
+  }
+}
+
+export default CommandHandler;

package/src/constants.ts

@@ -0,0 +1,12 @@
+export const DEFAULT_ARTIFACTS_DIR = "/tmp/artifacts";
+export const DEFAULT_ARTIFACT_IGNORE = `
+node_modules/
+.venv/
+.env/
+env/
+venv/
+dist/
+__pycache__/
+__pytest_cache__/
+.pytest_cache/
+`;