@keyou007/agent-bot 0.1.15-alpha.0 → 0.1.15-alpha.1

package/src/supervision/SupervisorDiagnostics.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { AppConfig } from "../config/schema.js";
+import { DailyLogStream, dailyLogPath } from "../logging/DailyLogStream.js";
 
 const MAX_LOG_BYTES = 10 * 1024 * 1024;
 const LOG_BACKUP_COUNT = 3;
@@ -42,8 +43,12 @@ type ExtendedProcessReport = typeof process.report & {
 
 export class SupervisorDiagnostics {
   readonly paths: SupervisorDiagnosticsPaths;
+  private workerStderrStream?: DailyLogStream;
 
-  constructor(config: Pick<AppConfig, "logging" | "storage">) {
+  constructor(
+    config: Pick<AppConfig, "logging" | "storage">,
+    private readonly clock: () => Date = () => new Date(),
+  ) {
     this.paths = resolveSupervisorDiagnosticsPaths(config);
   }
 
@@ -51,13 +56,13 @@ export class SupervisorDiagnostics {
     try {
       ensurePrivateDirectory(path.dirname(this.paths.supervisorLogPath));
       ensurePrivateDirectory(this.paths.crashReportDirectory);
-      rotateLogFile(this.paths.supervisorLogPath);
-      rotateLogFile(this.paths.workerStderrPath);
+      rotateLogFile(this.currentSupervisorLogPath());
+      rotateLogFile(this.currentWorkerStderrPath());
       this.configureCurrentProcessReports();
       this.writeEvent("diagnostics_initialized", {
         nodeVersion: process.versions.node,
-        supervisorLogPath: this.paths.supervisorLogPath,
-        workerStderrPath: this.paths.workerStderrPath,
+        supervisorLogPath: this.currentSupervisorLogPath(),
+        workerStderrPath: this.currentWorkerStderrPath(),
         crashReportDirectory: this.paths.crashReportDirectory,
       });
     } catch (error) {
@@ -73,40 +78,51 @@ export class SupervisorDiagnostics {
       ...data,
     })}\n`;
     try {
-      fs.appendFileSync(this.paths.supervisorLogPath, line, { encoding: "utf8", mode: 0o600 });
-      restrictFilePermissions(this.paths.supervisorLogPath);
+      const logPath = this.currentSupervisorLogPath();
+      rotateLogFile(logPath);
+      fs.appendFileSync(logPath, line, { encoding: "utf8", mode: 0o600 });
+      restrictFilePermissions(logPath);
     } catch (error) {
       writeFallbackDiagnostic(event, error);
     }
   }
 
-  openWorkerStderr(): number | "ignore" {
+  openWorkerStderr(): DailyLogStream | "ignore" {
     try {
-      rotateLogFile(this.paths.workerStderrPath);
-      fs.appendFileSync(
-        this.paths.workerStderrPath,
-        `${JSON.stringify({ event: "worker_started", time: new Date().toISOString() })}\n`,
-        { encoding: "utf8", mode: 0o600 },
-      );
-      restrictFilePermissions(this.paths.workerStderrPath);
-      return fs.openSync(this.paths.workerStderrPath, "a", 0o600);
+      const stream = new DailyLogStream(this.paths.workerStderrPath, {
+        clock: this.clock,
+        mode: 0o600,
+        beforeOpen: (filePath) => rotateLogFile(filePath),
+      });
+      stream.on("error", (error) => {
+        this.writeEvent("worker_stderr_write_failed", { error: errorMessage(error) });
+      });
+      stream.write(`${JSON.stringify({ event: "worker_started", time: this.clock().toISOString() })}\n`);
+      this.workerStderrStream = stream;
+      return stream;
     } catch (error) {
       this.writeEvent("worker_stderr_open_failed", { error: errorMessage(error) });
       return "ignore";
     }
   }
 
-  closeWorkerStderr(target: number | "ignore"): void {
-    if (typeof target !== "number") return;
-    try {
-      fs.closeSync(target);
-    } catch (error) {
-      this.writeEvent("worker_stderr_close_failed", { error: errorMessage(error) });
-    }
+  closeWorkerStderr(target: DailyLogStream | "ignore"): Promise<void> {
+    if (target === "ignore") return Promise.resolve();
+    return new Promise((resolve) => target.end(resolve));
+  }
+
+  currentSupervisorLogPath(date = this.clock()): string {
+    return dailyLogPath(this.paths.supervisorLogPath, date);
+  }
+
+  currentWorkerStderrPath(date = this.clock()): string {
+    return dailyLogPath(this.paths.workerStderrPath, date);
   }
 
   recordCrash(context: WorkerCrashContext): WorkerCrashRecord | undefined {
     try {
+      const exitedAt = new Date(context.exitedAt);
+      const crashDate = Number.isNaN(exitedAt.getTime()) ? this.clock() : exitedAt;
       const record: WorkerCrashRecord = {
         version: 1,
         ...context,
@@ -114,8 +130,8 @@ export class SupervisorDiagnostics {
         nodeVersion: process.versions.node,
         executablePath: process.execPath,
         cwd: process.cwd(),
-        supervisorLogPath: this.paths.supervisorLogPath,
-        workerStderrPath: this.paths.workerStderrPath,
+        supervisorLogPath: this.currentSupervisorLogPath(crashDate),
+        workerStderrPath: this.workerStderrStream?.filePath ?? this.currentWorkerStderrPath(crashDate),
         crashReportDirectory: this.paths.crashReportDirectory,
         diagnosticReports: findDiagnosticReports(
           this.paths.crashReportDirectory,

package/src/supervisor.ts

@@ -70,18 +70,24 @@ async function startChild(): Promise<void> {
         AGENT_BOT_SUPERVISED: "1",
         AGENT_BOT_RESTART_REASON: restartReason,
       }, restartNotificationTargets),
-      stdio: ["ignore", "ignore", workerStderr],
+      stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
     });
-  } finally {
-    diagnostics.closeWorkerStderr(workerStderr);
+    if (workerStderr === "ignore") {
+      child.stderr?.resume();
+    } else {
+      child.stderr?.pipe(workerStderr);
+    }
+  } catch (error) {
+    void diagnostics.closeWorkerStderr(workerStderr);
+    throw error;
   }
   const workerPid = child.pid;
   writeSupervisorLog("started", {
     pid: child.pid,
     restartReason,
     restartNotificationTargets,
-    workerStderrPath: diagnostics.paths.workerStderrPath,
+    workerStderrPath: diagnostics.currentWorkerStderrPath(),
     crashReportDirectory: diagnostics.paths.crashReportDirectory,
   });
 

package/src/utils/executeShellCommand.ts

@@ -11,10 +11,16 @@ export interface ShellCommandResult {
   outputTruncated: boolean;
 }
 
+export type ShellCommandOutputSnapshot = Pick<
+  ShellCommandResult,
+  "stdout" | "stderr" | "outputTruncated"
+>;
+
 export interface ShellCommandOptions {
   timeoutMs?: number;
   maxOutputBytes?: number;
   platform?: NodeJS.Platform;
+  onOutput?: (snapshot: ShellCommandOutputSnapshot) => void;
 }
 
 export function executeShellCommand(
@@ -40,8 +46,16 @@ export function executeShellCommand(
       child.kill();
     }, timeoutMs);
 
-    child.stdout.on("data", (chunk: Buffer) => output.append("stdout", chunk));
-    child.stderr.on("data", (chunk: Buffer) => output.append("stderr", chunk));
+    const appendOutput = (stream: "stdout" | "stderr", chunk: Buffer): void => {
+      output.append(stream, chunk);
+      try {
+        options.onOutput?.(output.result());
+      } catch {
+        // Output presentation must never interrupt the child process.
+      }
+    };
+    child.stdout.on("data", (chunk: Buffer) => appendOutput("stdout", chunk));
+    child.stderr.on("data", (chunk: Buffer) => appendOutput("stderr", chunk));
     child.once("error", (error) => {
       clearTimeout(timeout);
       reject(error);
@@ -68,30 +82,104 @@ function prepareShellCommand(command: string, platform: NodeJS.Platform): { comm
 }
 
 class BoundedOutput {
-  private readonly stdout: Buffer[] = [];
-  private readonly stderr: Buffer[] = [];
-  private retainedBytes = 0;
+  private retained: OutputChunk[] = [];
+  private readonly seenBytes = { stdout: 0, stderr: 0 };
+  private readonly headBytes: number;
+  private readonly tailBytes: number;
   private truncated = false;
 
-  constructor(private readonly maxBytes: number) {}
+  constructor(maxBytes: number) {
+    const normalizedMaxBytes = Math.max(1, Math.floor(maxBytes));
+    this.headBytes = Math.ceil(normalizedMaxBytes / 3);
+    this.tailBytes = normalizedMaxBytes - this.headBytes;
+  }
 
   append(stream: "stdout" | "stderr", chunk: Buffer): void {
-    const remaining = Math.max(0, this.maxBytes - this.retainedBytes);
-    if (remaining === 0) {
+    if (chunk.length === 0) return;
+    this.seenBytes[stream] += chunk.length;
+
+    if (!this.truncated) {
+      const next = [...this.retained, { stream, data: chunk }];
+      if (outputChunksLength(next) <= this.headBytes + this.tailBytes) {
+        this.retained = next;
+        return;
+      }
       this.truncated = true;
+      this.retained = [
+        ...takeOutputChunkHead(next, this.headBytes),
+        ...takeOutputChunkTail(next, this.tailBytes),
+      ];
       return;
     }
-    const retained = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
-    this[stream].push(retained);
-    this.retainedBytes += retained.length;
-    if (retained.length < chunk.length) this.truncated = true;
+
+    const head = takeOutputChunkHead(this.retained, this.headBytes);
+    const previousTail = takeOutputChunkTail(this.retained, this.tailBytes);
+    const tail = takeOutputChunkTail([...previousTail, { stream, data: chunk }], this.tailBytes);
+    this.retained = [...head, ...tail];
   }
 
-  result(): Pick<ShellCommandResult, "stdout" | "stderr" | "outputTruncated"> {
+  result(): ShellCommandOutputSnapshot {
     return {
-      stdout: Buffer.concat(this.stdout).toString("utf8"),
-      stderr: Buffer.concat(this.stderr).toString("utf8"),
+      stdout: this.streamResult("stdout"),
+      stderr: this.streamResult("stderr"),
       outputTruncated: this.truncated,
     };
   }
+
+  private streamResult(stream: "stdout" | "stderr"): string {
+    if (!this.truncated) {
+      return Buffer.concat(
+        this.retained.filter((chunk) => chunk.stream === stream).map((chunk) => chunk.data),
+      ).toString("utf8");
+    }
+    const head = takeOutputChunkHead(this.retained, this.headBytes)
+      .filter((chunk) => chunk.stream === stream);
+    const tail = takeOutputChunkTail(this.retained, this.tailBytes)
+      .filter((chunk) => chunk.stream === stream);
+
+    const retainedBytes = outputChunksLength([...head, ...tail]);
+    const marker = this.seenBytes[stream] > retainedBytes
+      ? Buffer.from("\n... output truncated ...\n", "utf8")
+      : Buffer.alloc(0);
+    return Buffer.concat([
+      ...head.map((chunk) => chunk.data),
+      marker,
+      ...tail.map((chunk) => chunk.data),
+    ]).toString("utf8");
+  }
+}
+
+interface OutputChunk {
+  stream: "stdout" | "stderr";
+  data: Buffer;
+}
+
+function outputChunksLength(chunks: OutputChunk[]): number {
+  return chunks.reduce((total, chunk) => total + chunk.data.length, 0);
+}
+
+function takeOutputChunkHead(chunks: OutputChunk[], maxBytes: number): OutputChunk[] {
+  const retained: OutputChunk[] = [];
+  let remaining = maxBytes;
+  for (const chunk of chunks) {
+    if (remaining <= 0) break;
+    const data = chunk.data.length <= remaining ? chunk.data : chunk.data.subarray(0, remaining);
+    retained.push({ stream: chunk.stream, data });
+    remaining -= data.length;
+  }
+  return retained;
+}
+
+function takeOutputChunkTail(chunks: OutputChunk[], maxBytes: number): OutputChunk[] {
+  const retained: OutputChunk[] = [];
+  let remaining = maxBytes;
+  for (let index = chunks.length - 1; index >= 0 && remaining > 0; index -= 1) {
+    const chunk = chunks[index]!;
+    const data = chunk.data.length <= remaining
+      ? chunk.data
+      : chunk.data.subarray(chunk.data.length - remaining);
+    retained.unshift({ stream: chunk.stream, data });
+    remaining -= data.length;
+  }
+  return retained;
 }