fix(logger): migrate to winston for simpler executable support

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-# Verifies lint, formatting, types, audit, and build all pass.
+# Builds the CLI and compiles it into executables for each platform for a smoke test.
 name: build
 on:
   workflow_call:
@@ -8,28 +8,41 @@ on:
         type: string
 
 jobs:
-  check:
-    runs-on: codebuild-agentcore-e2e-${{ github.run_id }}-${{ github.run_attempt }}
+  build:
+    name: Build (${{ matrix.name }})
+    runs-on: ${{ fromJSON(matrix.runner) }}
     permissions:
       contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Linux
+            runner: '["codebuild-agentcore-e2e-${{ github.run_id }}-${{ github.run_attempt }}"]'
+            target: linux-x64
+            binary: ./dist/bin/agentcore-linux-x64
+          - name: Windows
+            runner: '["codebuild-agentcore-e2e-${{ github.run_id }}-${{ github.run_attempt }}", "image:windows-1.0"]'
+            target: windows-x64
+            binary: ./dist/bin/agentcore-windows-x64.exe
+          # CodeBuild does not support macOS.
+          - name: macOS
+            runner: '["macos-latest"]'
+            target: darwin-arm64
+            binary: ./dist/bin/agentcore-darwin-arm64
     steps:
       - uses: actions/checkout@v7
         with:
           ref: ${{ inputs.ref }}
           persist-credentials: false
       - uses: oven-sh/setup-bun@v2
       - run: bun install --frozen-lockfile
-      - run: bun run lint:check
-        if: always()
-      - run: bun run format:check
-        if: always()
-      - run: bun run typecheck
-        if: always()
-      - run: bun audit
-        if: always()
+
       - run: bun run build
-        if: always()
+
       - run: bun pm pack
-        if: always()
-      - run: bun run compile
-        if: always()
+
+      - run: bun run compile:${{ matrix.target }}
+
+      - name: Smoke test binary
+        run: ${{ matrix.binary }} --help

.github/workflows/check.yml

@@ -0,0 +1,29 @@
+# Verifies lint, formatting, types, audit, and other static checks pass.
+name: check
+on:
+  workflow_call:
+    inputs:
+      ref:
+        required: true
+        type: string
+
+jobs:
+  check:
+    runs-on: codebuild-agentcore-e2e-${{ github.run_id }}-${{ github.run_attempt }}
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.ref }}
+          persist-credentials: false
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile
+      - run: bun run lint:check
+        if: always()
+      - run: bun run format:check
+        if: always()
+      - run: bun run typecheck
+        if: always()
+      - run: bun audit
+        if: always()

.github/workflows/ci.yml

@@ -13,6 +13,12 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  check:
+    uses: ./.github/workflows/check.yml
+    permissions:
+      contents: read
+    with:
+      ref: ${{ github.event.pull_request.head_sha || github.sha }}
   build:
     uses: ./.github/workflows/build.yml
     permissions:

package.json

@@ -61,8 +61,8 @@
     "react": "^19.2.7",
     "react-devtools-core": "^7.0.1",
     "react-router": "^8.1.0",
-    "pino": "^10.3.1",
-    "pino-roll": "^4.0.0",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0",
     "zod": "^4.4.3"
   }
 }

src/index.ts

@@ -50,13 +50,12 @@ process.exit(
       await rootHandler.route(argv);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
-      io.stderr.write(`${error.name}: ${error.message}\n`);
       rootLogger
         .child({ errorName: error.name, errorMessage: error.message, stack: error.stack ?? "" })
         .error();
       throw e;
     } finally {
-      await rootLogger.flush();
+      await rootLogger.end();
     }
   }),
 );

src/logging/fileLogger.tsx

@@ -1,4 +1,5 @@
-import pino from "pino";
+import winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
 import { type AsyncLogger, type LoggerBindings, type LogLevel } from "./types";
 
 export interface FileLoggerConfig {
@@ -9,54 +10,62 @@ export interface FileLoggerConfig {
   logLevel: LogLevel;
 }
 
-function wrapPinoLogger(pinoLogger: pino.Logger): AsyncLogger {
+function wrapWinstonLogger(
+  winstonLogger: winston.Logger,
+  transport: DailyRotateFile,
+  bindings: LoggerBindings,
+): AsyncLogger {
   const log =
-    (level: pino.Level) =>
+    (level: string) =>
     (...args: string[]) =>
-      pinoLogger[level](args.join(" "));
+      winstonLogger.log(level, args.join(" "), bindings);
+
   return {
     debug: log("debug"),
     info: log("info"),
     warn: log("warn"),
     error: log("error"),
-    child: (bindings) => wrapPinoLogger(pinoLogger.child(bindings)),
-    // we convert pino's flush method that accepts a callback into a promise to make it easier to work with.
-    // Note: we also treat flush as best-effort and swallow errors
-    flush: () => new Promise<void>((resolve) => pinoLogger.flush(() => resolve())),
+    child: (childBindings) =>
+      wrapWinstonLogger(winstonLogger, transport, { ...bindings, ...childBindings }),
+    end: () =>
+      new Promise<void>((resolve) => {
+        transport.on("finish", resolve);
+        // note: we prefer close over end since close calls end on the stream internally: https://github.com/winstonjs/winston-daily-rotate-file/blob/a1a4668cfea77476cd6a4a11f038c2aac9d10741/daily-rotate-file.js#L201-L207
+        if (transport.close) transport.close();
+      }),
   };
 }
 
 /**
  * Creates a logger that writes structured JSON to a rotating file.
  *
  * @param config - Logger configuration (file path, rotation limits, level).
- * @returns A {@link AsyncLogger} that writes to a rotating file via pino.
+ * @returns A {@link AsyncLogger} that writes to a rotating file via winston.
  */
 export function createFileLogger(config: FileLoggerConfig): AsyncLogger {
-  const maxSizeInMB = config.maxSizeInMB ?? 10;
-  const maxFileCount = config.maxFileCount ?? 5;
+  const maxSizeInMB = config.maxSizeInMB ?? 5;
+  const maxFileCount = config.maxFileCount ?? 10;
   const bindings = config.bindings ?? {};
-  return wrapPinoLogger(
-    pino({
-      level: config.logLevel,
-      base: undefined, // omit pid and hostname
-      formatters: {
-        level(label) {
-          return { level: label };
-        },
-      },
-      transport: {
-        target: "pino-roll",
-        options: {
-          extension: ".log",
-          dateFormat: "yyyy-MM-dd'T'HH-mm-ss",
-          // Rotate when file reaches {maxSizeInMB} MB, and start deleting once we have {maxFileCount} files
-          size: `${maxSizeInMB}m`,
-          limit: { count: maxFileCount },
-          file: config.filePath,
-          mkdir: true,
-        },
-      },
-    }),
-  ).child(bindings);
+
+  const transport = new DailyRotateFile({
+    filename: `${config.filePath}-%DATE%`,
+    extension: ".log",
+    datePattern: "YYYY-MM-DD",
+    maxSize: `${maxSizeInMB}m`,
+    maxFiles: maxFileCount,
+    createSymlink: false,
+  });
+
+  const jsonFormat = winston.format.printf((info) => {
+    const { level, message, ...rest } = info;
+    return JSON.stringify({ level, msg: message, time: Date.now(), ...rest });
+  });
+
+  const logger = winston.createLogger({
+    level: config.logLevel,
+    format: jsonFormat,
+    transports: [transport],
+  });
+
+  return wrapWinstonLogger(logger, transport, bindings);
 }

src/logging/types.tsx

@@ -27,5 +27,6 @@ export interface Logger {
 /** An extension of {@link Logger} that writes logs asynchronously and requires output to be flushed */
 export interface AsyncLogger extends Logger {
   child: (bindings: LoggerBindings) => AsyncLogger;
-  flush: () => Promise<void>;
+  /** Flushes the pending logs and closes the underlying logging streams **/
+  end: () => Promise<void>;
 }

src/middleware/withLogging.test.ts

@@ -21,7 +21,7 @@ describe("withLogging", () => {
   });
 
   afterEach(async () => {
-    await logger.flush();
+    await logger.end();
     await rm(tempDir, { recursive: true, force: true });
   });
 

src/runnable/index.tsx

@@ -27,7 +27,9 @@ export async function runWithExitCode(
   try {
     await fn(argv);
     return ExitCode.SUCCESS;
-  } catch {
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    console.error(`${error.name}: ${error.message}`);
     return ExitCode.FAILURE;
   }
 }

src/testing/logging.tsx

@@ -58,8 +58,7 @@ export async function assertLogsMatch(
 ): Promise<void> {
   let lastResults: ReturnType<typeof evaluateQueries> = [];
 
-  // pino-roll writes via async worker threads, so logs may not be flushed to
-  // disk immediately. Poll until all query conditions are satisfied.
+  // Poll until all query conditions are satisfied.
   try {
     await waitFor(async () => {
       const content = await readLogFile(dir);