child_process: spawnSync option stdio stdout support stream

Refs: #52776

Author: Tseian

doc/api/packages.md

@@ -1012,7 +1012,7 @@ added: v0.4.0
 The `"main"` field defines the entry point of a package when imported by name
 via a `node_modules` lookup.  Its value is a path.
 
-The [`"exports"`][] field, if it exists, takes precedence over the
+The [`"exports"`][] field, if it exists, takes precedence over the
 `"main"` field when importing the package by name.
 
 It also defines the script that is used when the [package directory is loaded

src/spawn_sync.cc

@@ -25,6 +25,7 @@
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
+#include "stream_wrap.h"
 #include "string_bytes.h"
 #include "util-inl.h"
 
@@ -1063,12 +1064,26 @@ Maybe<int> SyncProcessRunner::ParseStdioOption(int child_fd,
       return Nothing<int>();
     }
     return Just(AddStdioInheritFD(child_fd, inherit_fd));
-  }
+  } else if (js_type->StrictEquals(env()->wrap_string())) {
+    Local<Value> val;
+    if (!js_stdio_option->Get(context, env()->handle_string()).ToLocal(&val)) {
+      return Nothing<int>();
+    }
+    if (!val->IsObject()) {
+      return Just<int>(UV_EINVAL);
+    }
 
-  Utf8Value stdio_type(env()->isolate(), js_type);
-  fprintf(stderr, "invalid child stdio type: %s\n", stdio_type.out());
+    Local<Object> handle = val.As<Object>();
+    Local<v8::FunctionTemplate> sw = env()->libuv_stream_wrap_ctor_template();
+    if (sw.IsEmpty() || !sw->HasInstance(handle)) {
+      return Just<int>(UV_EINVAL);
+    }
 
-  UNREACHABLE();
+    uv_stream_t* stream = LibuvStreamWrap::From(env(), handle)->stream();
+    return Just(AddStdioInheritStream(child_fd, stream));
+  }
+
+  return Just<int>(UV_EINVAL);
 }
 
 int SyncProcessRunner::AddStdioIgnore(uint32_t child_fd) {
@@ -1116,6 +1131,17 @@ int SyncProcessRunner::AddStdioInheritFD(uint32_t child_fd, int inherit_fd) {
   return 0;
 }
 
+int SyncProcessRunner::AddStdioInheritStream(uint32_t child_fd,
+                                             uv_stream_t* stream) {
+  CHECK_LT(child_fd, stdio_count_);
+  CHECK(!stdio_pipes_[child_fd]);
+
+  uv_stdio_containers_[child_fd].flags = UV_INHERIT_STREAM;
+  uv_stdio_containers_[child_fd].data.stream = stream;
+
+  return 0;
+}
+
 Maybe<int> SyncProcessRunner::CopyJsString(Local<Value> js_value,
                                            const char** target) {
   Isolate* isolate = env()->isolate();

src/spawn_sync.h

@@ -185,6 +185,7 @@ class SyncProcessRunner {
                           bool writable,
                           uv_buf_t input_buffer);
   inline int AddStdioInheritFD(uint32_t child_fd, int inherit_fd);
+  inline int AddStdioInheritStream(uint32_t child_fd, uv_stream_t* stream);
 
   static bool IsSet(v8::Local<v8::Value> value);
   v8::Maybe<int> CopyJsString(v8::Local<v8::Value> js_value,

test/parallel/test-child-process-spawnsync.js

@@ -65,3 +65,37 @@ assert.deepStrictEqual(ret_err.spawnargs, ['bar']);
   ];
   assert.deepStrictEqual(retUTF8.output, stringifiedDefault);
 }
+
+{
+  // Verify support for stdio.wrap via using another child process stream.
+  // This is the same logic as in ch_sy.js, expressed as a deterministic test.
+  if (common.isWindows) {
+    common.skip('Not applicable on Windows');
+  }
+
+  const { spawn } = require('child_process');
+  const childA = spawn(
+    process.execPath,
+    ['-e', 'process.stdin.pipe(process.stdout);'],
+    { stdio: ['pipe', 'pipe', 'ignore'] }
+  );
+
+  let collected = '';
+  childA.stdout.setEncoding('utf8');
+  childA.stdout.on('data', (chunk) => { collected += chunk; });
+
+  childA.on('exit', common.mustCall((code) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(collected, 'hi');
+  }));
+
+  const result = spawnSync(
+    process.execPath,
+    ['-e', 'process.stdout.write("hi")'],
+    { stdio: ['inherit', childA.stdin, 'inherit'] }
+  );
+
+  assert.strictEqual(result.status, 0);
+  // Explicitly close the wrapped stream on the parent side so childA receives EOF.
+  childA.stdin.end();
+}