Function writeFile

src/node/runtime/RemoteRuntime.ts:391–460

* Write file contents atomically via exec. * Uses temp file + mv for atomic write.

(filePath: string, abortSignal?: AbortSignal)

   * Uses temp file + mv for atomic write.
   */
  writeFile(filePath: string, abortSignal?: AbortSignal): WritableStream<Uint8Array> {
    const quotedPath = this.quoteForRemote(filePath);
    const tempPath = getAtomicWriteTempPath(filePath);
    const quotedTempPath = this.quoteForRemote(tempPath);

    // Build write command - subclasses can override buildWriteCommand for special handling
    const writeCommand = this.buildWriteCommand(quotedPath, quotedTempPath);

    let execPromise: Promise<ExecStream> | null = null;
    const writeAbortController = new AbortController();
    const abortWrite = () => writeAbortController.abort();
    if (abortSignal?.aborted) {
      writeAbortController.abort();
    } else {
      abortSignal?.addEventListener("abort", abortWrite, { once: true });
    }
    const cleanupAbortForwarder = () => {
      abortSignal?.removeEventListener("abort", abortWrite);
    };

    const getExecStream = () => {
      execPromise ??= this.exec(writeCommand, {
        cwd: this.getBasePath(),
        timeout: 300,
        abortSignal: writeAbortController.signal,
      });
      return execPromise;
    };

    return new WritableStream<Uint8Array>({
      write: async (chunk: Uint8Array) => {
        const stream = await getExecStream();
        const writer = stream.stdin.getWriter();
        try {
          await writer.write(chunk);
        } finally {
          writer.releaseLock();
        }
      },
      close: async () => {
        try {
          const stream = await getExecStream();
          await stream.stdin.close();
          const exitCode = await stream.exitCode;

          if (exitCode !== 0) {
            const stderr = await streamToString(stream.stderr);
            throw new RuntimeError(`Failed to write file ${filePath}: ${stderr}`, "file_io");
          }
        } finally {
          cleanupAbortForwarder();
        }
      },
      abort: async (reason?: unknown) => {
        writeAbortController.abort();
        if (execPromise) {
          try {
            const stream = await execPromise;