fix: restore post-job compose logs header

Co-authored-by: neilime <314088+neilime@users.noreply.github.com>

dist/index.js

@@ -26549,7 +26549,7 @@ var require_dist2 = __commonJS({
       return (0, exports.restartMany)([service], options);
     };
     exports.restartOne = restartOne;
-    var logs2 = function(services, options = {}) {
+    var logs = function(services, options = {}) {
       const args = Array.isArray(services) ? services : [services];
       if (options.follow) {
         args.unshift("--follow");
@@ -26559,7 +26559,7 @@ var require_dist2 = __commonJS({
       }
       return (0, exports.execCompose)("logs", args, options);
     };
-    exports.logs = logs2;
+    exports.logs = logs;
     var port = async function(service, containerPort, options) {
       const args = [service, containerPort];
       try {
@@ -31374,6 +31374,7 @@ function info(message) {
 
 // src/services/docker-compose.service.ts
 var import_docker_compose = __toESM(require_dist2(), 1);
+import { spawn as spawn2 } from "node:child_process";
 var DockerComposeService = class {
   async up({ upFlags, services, ...optionsInputs }) {
     const options = {
@@ -31402,15 +31403,52 @@ var DockerComposeService = class {
     }
   }
   async logs({ services, ...optionsInputs }) {
-    const options = {
+    const commandArgs = this.getDockerComposeCommandArgs("logs", {
-      ...this.getCommonOptions(optionsInputs),
+      dockerFlags: optionsInputs.dockerFlags,
-      follow: false
+      composeFlags: optionsInputs.composeFlags,
-    };
+      composeFiles: optionsInputs.composeFiles,
-    const { err, out } = await (0, import_docker_compose.logs)(services, options);
+      commandArgs: services
-    return {
+    });
-      error: err,
+    return new Promise((resolve2) => {
-      output: out
+      let settled = false;
-    };
+      const childProcess = spawn2("docker", commandArgs, {
+        cwd: optionsInputs.cwd
+      });
+      childProcess.on("error", (error2) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve2({
+          error: `Unable to collect docker compose logs: ${error2.message}`,
+          output: ""
+        });
+      });
+      if (!childProcess.stdout || !childProcess.stderr) {
+        settled = true;
+        resolve2({
+          error: "Unable to collect docker compose logs: stdout/stderr unavailable",
+          output: ""
+        });
+        return;
+      }
+      childProcess.stdout.on("data", (chunk) => {
+        optionsInputs.serviceLogger(chunk.toString());
+      });
+      childProcess.stderr.on("data", (chunk) => {
+        optionsInputs.serviceLogger(chunk.toString());
+      });
+      childProcess.on("close", (exitCode, signal) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve2({
+          error: signal ? `Docker Compose logs command failed with signal ${signal}` : exitCode !== null && exitCode !== 0 ? `Docker Compose logs command failed with exit code ${exitCode}` : "",
+          output: ""
+        });
+      });
+    });
   }
   getCommonOptions({
     dockerFlags,
@@ -31430,6 +31468,24 @@ var DockerComposeService = class {
       }
     };
   }
+  /**
+   * Builds docker CLI arguments in the order expected by `docker compose`.
+   */
+  getDockerComposeCommandArgs(command, {
+    dockerFlags,
+    composeFlags,
+    composeFiles,
+    commandArgs
+  }) {
+    return [
+      ...dockerFlags,
+      "compose",
+      ...composeFlags,
+      ...composeFiles.flatMap((composeFile) => ["-f", composeFile]),
+      command,
+      ...commandArgs
+    ];
+  }
   /**
    * Formats docker-compose errors into proper Error objects with readable messages
    */

dist/post.js

@@ -26549,7 +26549,7 @@ var require_dist2 = __commonJS({
       return (0, exports.restartMany)([service], options);
     };
     exports.restartOne = restartOne;
-    var logs2 = function(services, options = {}) {
+    var logs = function(services, options = {}) {
       const args = Array.isArray(services) ? services : [services];
       if (options.follow) {
         args.unshift("--follow");
@@ -26559,7 +26559,7 @@ var require_dist2 = __commonJS({
       }
       return (0, exports.execCompose)("logs", args, options);
     };
-    exports.logs = logs2;
+    exports.logs = logs;
     var port = async function(service, containerPort, options) {
       const args = [service, containerPort];
       try {
@@ -27111,6 +27111,7 @@ function info(message) {
 
 // src/services/docker-compose.service.ts
 var import_docker_compose = __toESM(require_dist2(), 1);
+import { spawn } from "node:child_process";
 var DockerComposeService = class {
   async up({ upFlags, services, ...optionsInputs }) {
     const options = {
@@ -27139,15 +27140,52 @@ var DockerComposeService = class {
     }
   }
   async logs({ services, ...optionsInputs }) {
-    const options = {
+    const commandArgs = this.getDockerComposeCommandArgs("logs", {
-      ...this.getCommonOptions(optionsInputs),
+      dockerFlags: optionsInputs.dockerFlags,
-      follow: false
+      composeFlags: optionsInputs.composeFlags,
-    };
+      composeFiles: optionsInputs.composeFiles,
-    const { err, out } = await (0, import_docker_compose.logs)(services, options);
+      commandArgs: services
-    return {
+    });
-      error: err,
+    return new Promise((resolve) => {
-      output: out
+      let settled = false;
-    };
+      const childProcess = spawn("docker", commandArgs, {
+        cwd: optionsInputs.cwd
+      });
+      childProcess.on("error", (error2) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve({
+          error: `Unable to collect docker compose logs: ${error2.message}`,
+          output: ""
+        });
+      });
+      if (!childProcess.stdout || !childProcess.stderr) {
+        settled = true;
+        resolve({
+          error: "Unable to collect docker compose logs: stdout/stderr unavailable",
+          output: ""
+        });
+        return;
+      }
+      childProcess.stdout.on("data", (chunk) => {
+        optionsInputs.serviceLogger(chunk.toString());
+      });
+      childProcess.stderr.on("data", (chunk) => {
+        optionsInputs.serviceLogger(chunk.toString());
+      });
+      childProcess.on("close", (exitCode, signal) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve({
+          error: signal ? `Docker Compose logs command failed with signal ${signal}` : exitCode !== null && exitCode !== 0 ? `Docker Compose logs command failed with exit code ${exitCode}` : "",
+          output: ""
+        });
+      });
+    });
   }
   getCommonOptions({
     dockerFlags,
@@ -27167,6 +27205,24 @@ var DockerComposeService = class {
       }
     };
   }
+  /**
+   * Builds docker CLI arguments in the order expected by `docker compose`.
+   */
+  getDockerComposeCommandArgs(command, {
+    dockerFlags,
+    composeFlags,
+    composeFiles,
+    commandArgs
+  }) {
+    return [
+      ...dockerFlags,
+      "compose",
+      ...composeFlags,
+      ...composeFiles.flatMap((composeFile) => ["-f", composeFile]),
+      command,
+      ...commandArgs
+    ];
+  }
   /**
    * Formats docker-compose errors into proper Error objects with readable messages
    */
@@ -27335,20 +27391,25 @@ async function run() {
     const inputService = new InputService();
     const dockerComposeService = new DockerComposeService();
     const inputs = inputService.getInputs();
-    const { error: error2, output } = await dockerComposeService.logs({
+    try {
-      dockerFlags: inputs.dockerFlags,
+      loggerService.debug("docker compose logs:");
-      composeFiles: inputs.composeFiles,
+      const { error: error2 } = await dockerComposeService.logs({
-      composeFlags: inputs.composeFlags,
+        dockerFlags: inputs.dockerFlags,
-      cwd: inputs.cwd,
+        composeFiles: inputs.composeFiles,
-      services: inputs.services,
+        composeFlags: inputs.composeFlags,
-      serviceLogger: loggerService.getServiceLogger(inputs.serviceLogLevel)
+        cwd: inputs.cwd,
-    });
+        services: inputs.services,
-    if (error2) {
+        serviceLogger: loggerService.getServiceLogger(inputs.serviceLogLevel)
-      loggerService.debug(`docker compose error:
+      });
+      if (error2) {
+        loggerService.debug(`docker compose error:
 ${error2}`);
+      }
+    } catch (error2) {
+      loggerService.warn(
+        `Unable to collect docker compose logs before cleanup: ${error2 instanceof Error ? error2.message : JSON.stringify(error2)}`
+      );
     }
-    loggerService.debug(`docker compose logs:
-${output}`);
     await dockerComposeService.down({
       dockerFlags: inputs.dockerFlags,
       composeFiles: inputs.composeFiles,

src/post-runner.test.ts

@@ -42,6 +42,7 @@ const { DockerComposeService } = await import(
 describe("run", () => {
   let infoMock: ReturnType<typeof vi.spyOn>;
   let debugMock: ReturnType<typeof vi.spyOn>;
+  let warnMock: ReturnType<typeof vi.spyOn>;
   let getInputsMock: ReturnType<typeof vi.spyOn>;
   let serviceDownMock: ReturnType<typeof vi.spyOn>;
   let serviceLogsMock: ReturnType<typeof vi.spyOn>;
@@ -55,12 +56,15 @@ describe("run", () => {
     debugMock = vi
       .spyOn(LoggerService.prototype, "debug")
       .mockImplementation(() => {});
+    warnMock = vi
+      .spyOn(LoggerService.prototype, "warn")
+      .mockImplementation(() => {});
     getInputsMock = vi.spyOn(InputService.prototype, "getInputs");
     serviceDownMock = vi.spyOn(DockerComposeService.prototype, "down");
     serviceLogsMock = vi.spyOn(DockerComposeService.prototype, "logs");
   });
 
-  it("should bring down docker compose service(s) and log output", async () => {
+  it("should bring down docker compose service(s)", async () => {
     // Arrange
     getInputsMock.mockImplementation(() => ({
       dockerFlags: [],
@@ -75,7 +79,7 @@ describe("run", () => {
       serviceLogLevel: LogLevel.Debug,
     }));
 
-    serviceLogsMock.mockResolvedValue({ error: "", output: "test logs" });
+    serviceLogsMock.mockResolvedValue({ error: "", output: "" });
     serviceDownMock.mockResolvedValue();
 
     // Act
@@ -100,12 +104,11 @@ describe("run", () => {
       serviceLogger: debugMock,
     });
 
-    expect(debugMock).toHaveBeenCalledWith("docker compose logs:\ntest logs");
     expect(infoMock).toHaveBeenCalledWith("docker compose is down");
     expect(setFailedMock).not.toHaveBeenCalled();
   });
 
-  it("should log docker composer errors if any", async () => {
+  it("should log docker compose command errors if any", async () => {
     // Arrange
     getInputsMock.mockImplementation(() => ({
       dockerFlags: [],
@@ -131,15 +134,40 @@ describe("run", () => {
     await run();
 
     // Assert
+    expect(debugMock).toHaveBeenCalledWith("docker compose logs:");
     expect(debugMock).toHaveBeenCalledWith(
       "docker compose error:\ntest logs error",
     );
-    expect(debugMock).toHaveBeenCalledWith(
-      "docker compose logs:\ntest logs output",
-    );
     expect(infoMock).toHaveBeenCalledWith("docker compose is down");
   });
 
+  it("should continue cleanup when collecting logs fails", async () => {
+    getInputsMock.mockImplementation(() => ({
+      dockerFlags: [],
+      composeFiles: ["docker-compose.yml"],
+      services: [],
+      composeFlags: [],
+      upFlags: [],
+      downFlags: [],
+      cwd: "/current/working/dir",
+      composeVersion: null,
+      githubToken: null,
+      serviceLogLevel: LogLevel.Debug,
+    }));
+
+    serviceLogsMock.mockRejectedValue(new Error("Test logs error"));
+    serviceDownMock.mockResolvedValue();
+
+    await run();
+
+    expect(warnMock).toHaveBeenCalledWith(
+      "Unable to collect docker compose logs before cleanup: Test logs error",
+    );
+    expect(serviceDownMock).toHaveBeenCalled();
+    expect(infoMock).toHaveBeenCalledWith("docker compose is down");
+    expect(setFailedMock).not.toHaveBeenCalled();
+  });
+
   it("should set failed when an error occurs", async () => {
     // Arrange
     getInputsMock.mockImplementation(() => {

src/post-runner.ts

@@ -15,21 +15,27 @@ export async function run(): Promise<void> {
 
     const inputs = inputService.getInputs();
 
-    const { error, output } = await dockerComposeService.logs({
+    try {
-      dockerFlags: inputs.dockerFlags,
+      loggerService.debug("docker compose logs:");
-      composeFiles: inputs.composeFiles,
-      composeFlags: inputs.composeFlags,
-      cwd: inputs.cwd,
-      services: inputs.services,
-      serviceLogger: loggerService.getServiceLogger(inputs.serviceLogLevel),
-    });
 
-    if (error) {
+      const { error } = await dockerComposeService.logs({
-      loggerService.debug(`docker compose error:\n${error}`);
+        dockerFlags: inputs.dockerFlags,
+        composeFiles: inputs.composeFiles,
+        composeFlags: inputs.composeFlags,
+        cwd: inputs.cwd,
+        services: inputs.services,
+        serviceLogger: loggerService.getServiceLogger(inputs.serviceLogLevel),
+      });
+
+      if (error) {
+        loggerService.debug(`docker compose error:\n${error}`);
+      }
+    } catch (error) {
+      loggerService.warn(
+        `Unable to collect docker compose logs before cleanup: ${error instanceof Error ? error.message : JSON.stringify(error)}`,
+      );
     }
 
-    loggerService.debug(`docker compose logs:\n${output}`);
-
     await dockerComposeService.down({
       dockerFlags: inputs.dockerFlags,
       composeFiles: inputs.composeFiles,

src/post.test.ts

@@ -73,7 +73,7 @@ describe("post", () => {
       serviceLogLevel: LogLevel.Debug,
     }));
 
-    serviceLogsMock.mockResolvedValue({ error: "", output: "test logs" });
+    serviceLogsMock.mockResolvedValue({ error: "", output: "" });
     serviceDownMock.mockResolvedValueOnce();
 
     await import("./post.js");
@@ -97,10 +97,6 @@ describe("post", () => {
       serviceLogger: debugMock,
     });
 
-    expect(debugMock).toHaveBeenNthCalledWith(
-      1,
-      "docker compose logs:\ntest logs",
-    );
     expect(infoMock).toHaveBeenNthCalledWith(1, "docker compose is down");
 
     expect(setFailedMock).not.toHaveBeenCalled();

src/services/docker-compose.service.test.ts

@@ -1,8 +1,8 @@
 import type {
-  IDockerComposeLogOptions,
   IDockerComposeOptions,
   IDockerComposeResult,
 } from "docker-compose";
+import { EventEmitter } from "node:events";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 // Mock docker-compose before importing the module under test
@@ -17,19 +17,16 @@ const upManyMock =
   >();
 const downMock =
   vi.fn<(options: IDockerComposeOptions) => Promise<IDockerComposeResult>>();
-const logsMock =
+const spawnMock = vi.fn();
-  vi.fn<
-    (
-      services: string[],
-      options: IDockerComposeLogOptions,
-    ) => Promise<IDockerComposeResult>
-  >();
 
 vi.doMock("docker-compose", () => ({
   upAll: upAllMock,
   upMany: upManyMock,
   down: downMock,
-  logs: logsMock,
+}));
+
+vi.doMock("node:child_process", () => ({
+  spawn: spawnMock,
 }));
 
 // Dynamic import after mock setup
@@ -360,7 +357,7 @@ describe("DockerComposeService", () => {
   });
 
   describe("logs", () => {
-    it("should call logs with correct options", async () => {
+    it("should stream logs with correct command arguments", async () => {
       const debugMock = vi.fn();
       const logsInputs = {
         dockerFlags: [] as string[],
@@ -371,20 +368,156 @@ describe("DockerComposeService", () => {
         serviceLogger: debugMock,
       };
 
-      logsMock.mockResolvedValue({ exitCode: 0, err: "", out: "logs" });
+      const stdout = new EventEmitter();
+      const stderr = new EventEmitter();
+      const childProcess = new EventEmitter() as EventEmitter & {
+        stdout: EventEmitter;
+        stderr: EventEmitter;
+      };
+      childProcess.stdout = stdout;
+      childProcess.stderr = stderr;
+      spawnMock.mockReturnValue(childProcess);
 
-      await service.logs(logsInputs);
+      const logsPromise = service.logs(logsInputs);
 
-      expect(logsMock).toHaveBeenCalledWith(["helloworld2", "helloworld3"], {
+      expect(spawnMock).toHaveBeenCalledWith("docker", [
-        composeOptions: [],
+        "compose",
-        config: ["docker-compose.yml"],
+        "-f",
+        "docker-compose.yml",
+        "logs",
+        "helloworld2",
+        "helloworld3",
+      ], {
         cwd: "/current/working/dir",
-        executable: {
+      });
-          executablePath: "docker",
+
-          options: [],
+      stdout.emit("data", Buffer.from("logs"));
-        },
+      stderr.emit("data", Buffer.from("error logs"));
-        follow: false,
+      childProcess.emit("close", 0);
-        callback: expect.any(Function),
+
+      await expect(logsPromise).resolves.toEqual({ error: "", output: "" });
+      expect(debugMock).toHaveBeenNthCalledWith(1, "logs");
+      expect(debugMock).toHaveBeenNthCalledWith(2, "error logs");
+    });
+
+    it("should return a non-fatal error message when logs command fails", async () => {
+      const logsInputs = {
+        dockerFlags: ["--context", "dev"] as string[],
+        composeFiles: ["docker-compose.yml"] as string[],
+        services: [] as string[],
+        composeFlags: ["--profile", "ci"] as string[],
+        cwd: "/current/working/dir",
+        serviceLogger: vi.fn(),
+      };
+
+      const childProcess = new EventEmitter() as EventEmitter & {
+        stdout: EventEmitter;
+        stderr: EventEmitter;
+      };
+      childProcess.stdout = new EventEmitter();
+      childProcess.stderr = new EventEmitter();
+      spawnMock.mockReturnValue(childProcess);
+
+      const logsPromise = service.logs(logsInputs);
+
+      expect(spawnMock).toHaveBeenCalledWith("docker", [
+        "--context",
+        "dev",
+        "compose",
+        "--profile",
+        "ci",
+        "-f",
+        "docker-compose.yml",
+        "logs",
+      ], {
+        cwd: "/current/working/dir",
+      });
+
+      childProcess.emit("close", 1);
+
+      await expect(logsPromise).resolves.toEqual({
+        error: "Docker Compose logs command failed with exit code 1",
+        output: "",
+      });
+    });
+
+    it("should return a non-fatal error message when logs command is terminated by a signal", async () => {
+      const logsInputs = {
+        dockerFlags: [] as string[],
+        composeFiles: ["docker-compose.yml"] as string[],
+        services: [] as string[],
+        composeFlags: [] as string[],
+        cwd: "/current/working/dir",
+        serviceLogger: vi.fn(),
+      };
+
+      const childProcess = new EventEmitter() as EventEmitter & {
+        stdout: EventEmitter;
+        stderr: EventEmitter;
+      };
+      childProcess.stdout = new EventEmitter();
+      childProcess.stderr = new EventEmitter();
+      spawnMock.mockReturnValue(childProcess);
+
+      const logsPromise = service.logs(logsInputs);
+
+      childProcess.emit("close", null, "SIGTERM");
+
+      await expect(logsPromise).resolves.toEqual({
+        error: "Docker Compose logs command failed with signal SIGTERM",
+        output: "",
+      });
+    });
+
+    it("should return a non-fatal error message when spawning logs fails", async () => {
+      const logsInputs = {
+        dockerFlags: [] as string[],
+        composeFiles: ["docker-compose.yml"] as string[],
+        services: [] as string[],
+        composeFlags: [] as string[],
+        cwd: "/current/working/dir",
+        serviceLogger: vi.fn(),
+      };
+
+      const childProcess = new EventEmitter() as EventEmitter & {
+        stdout: EventEmitter;
+        stderr: EventEmitter;
+      };
+      childProcess.stdout = new EventEmitter();
+      childProcess.stderr = new EventEmitter();
+      spawnMock.mockReturnValue(childProcess);
+
+      const logsPromise = service.logs(logsInputs);
+
+      childProcess.emit("error", new Error("spawn ENOENT"));
+
+      await expect(logsPromise).resolves.toEqual({
+        error: "Unable to collect docker compose logs: spawn ENOENT",
+        output: "",
+      });
+    });
+
+    it("should return a non-fatal error message when output streams are unavailable", async () => {
+      const logsInputs = {
+        dockerFlags: [] as string[],
+        composeFiles: ["docker-compose.yml"] as string[],
+        services: [] as string[],
+        composeFlags: [] as string[],
+        cwd: "/current/working/dir",
+        serviceLogger: vi.fn(),
+      };
+
+      const childProcess = new EventEmitter() as EventEmitter & {
+        stdout: EventEmitter | null;
+        stderr: EventEmitter | null;
+      };
+      childProcess.stdout = null;
+      childProcess.stderr = null;
+      spawnMock.mockReturnValue(childProcess);
+
+      await expect(service.logs(logsInputs)).resolves.toEqual({
+        error: "Unable to collect docker compose logs: stdout/stderr unavailable",
+        output: "",
       });
     });
   });

src/services/docker-compose.service.ts

@@ -1,9 +1,8 @@
+import { spawn } from "node:child_process";
 import {
   down,
-  type IDockerComposeLogOptions,
   type IDockerComposeOptions,
   type IDockerComposeResult,
-  logs,
   upAll,
   upMany,
 } from "docker-compose";
@@ -60,17 +59,60 @@ export class DockerComposeService {
     error: string;
     output: string;
   }> {
-    const options: IDockerComposeLogOptions = {
+    const commandArgs = this.getDockerComposeCommandArgs("logs", {
-      ...this.getCommonOptions(optionsInputs),
+      dockerFlags: optionsInputs.dockerFlags,
-      follow: false,
+      composeFlags: optionsInputs.composeFlags,
-    };
+      composeFiles: optionsInputs.composeFiles,
+      commandArgs: services,
+    });
 
-    const { err, out } = await logs(services, options);
+    return new Promise((resolve) => {
+      let settled = false;
+      const childProcess = spawn("docker", commandArgs, {
+        cwd: optionsInputs.cwd,
+      });
 
-    return {
+      childProcess.on("error", (error) => {
-      error: err,
+        if (settled) {
-      output: out,
+          return;
-    };
+        }
+        settled = true;
+        resolve({
+          error: `Unable to collect docker compose logs: ${error.message}`,
+          output: "",
+        });
+      });
+      if (!childProcess.stdout || !childProcess.stderr) {
+        settled = true;
+        resolve({
+          error: "Unable to collect docker compose logs: stdout/stderr unavailable",
+          output: "",
+        });
+        return;
+      }
+
+      childProcess.stdout.on("data", (chunk: Buffer | string) => {
+        optionsInputs.serviceLogger(chunk.toString());
+      });
+      childProcess.stderr.on("data", (chunk: Buffer | string) => {
+        optionsInputs.serviceLogger(chunk.toString());
+      });
+      childProcess.on("close", (exitCode, signal) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve({
+          error:
+            signal
+              ? `Docker Compose logs command failed with signal ${signal}`
+              : exitCode !== null && exitCode !== 0
+                ? `Docker Compose logs command failed with exit code ${exitCode}`
+                : "",
+          output: "",
+        });
+      });
+    });
   }
 
   private getCommonOptions({
@@ -92,6 +134,33 @@ export class DockerComposeService {
     };
   }
 
+  /**
+   * Builds docker CLI arguments in the order expected by `docker compose`.
+   */
+  private getDockerComposeCommandArgs(
+    command: "logs",
+    {
+      dockerFlags,
+      composeFlags,
+      composeFiles,
+      commandArgs,
+    }: {
+      dockerFlags: string[];
+      composeFlags: string[];
+      composeFiles: string[];
+      commandArgs: string[];
+    },
+  ): string[] {
+    return [
+      ...dockerFlags,
+      "compose",
+      ...composeFlags,
+      ...composeFiles.flatMap((composeFile) => ["-f", composeFile]),
+      command,
+      ...commandArgs,
+    ];
+  }
+
   /**
    * Formats docker-compose errors into proper Error objects with readable messages
    */