Class MigratedBackgroundHandle

src/node/services/backgroundProcessExecutor.ts:423–577

* Handle for a migrated foreground process. * * Unlike RuntimeBackgroundHandle which uses runtime.exec for file operations, * this handle uses local filesystem directly because the streams are already * being piped to the local machine (even for SSH runtime). * * Both stdout and stderr are wri

 * Both stdout and stderr are written to a unified output.log file.
 */
class MigratedBackgroundHandle implements BackgroundHandle {
  private exitCodeValue: number | null = null;
  private consuming = false;
  private outputFd: fs.FileHandle | null = null;

  constructor(
    private readonly execStream: ExecStream,
    public readonly outputDir: string,
    private readonly outputPath: string
  ) {}

  /**
   * Start consuming remaining output from streams and writing to unified file.
   * Called after handle is created to begin background file writing.
   */
  startConsuming(): void {
    if (this.consuming) return;
    this.consuming = true;

    // Open output file once, consume both streams to it
    void this.consumeStreams();

    // Track exit code
    void this.execStream.exitCode.then((code) => {
      this.exitCodeValue = code;
      // Write exit code to file
      void this.writeExitCode(code);
    });
  }

  /**
   * Consume both stdout and stderr streams and append to unified output file.
   */
  private async consumeStreams(): Promise<void> {
    try {
      this.outputFd = await fs.open(this.outputPath, "a");

      // Consume both streams concurrently, both writing to same file
      await Promise.all([
        this.consumeStream(this.execStream.stdout),
        this.consumeStream(this.execStream.stderr),
      ]);
    } catch (error) {
      log.debug(`MigratedBackgroundHandle.consumeStreams: ${errorMsg(error)}`);
    } finally {
      if (this.outputFd) {
        await this.outputFd.close();
        this.outputFd = null;
      }
    }
  }

  /**
   * Consume a stream and append to the shared output file.
   */
  private async consumeStream(stream: ReadableStream<Uint8Array>): Promise<void> {
    try {
      const reader = stream.getReader();