`process.stdin` exists but doesn't totally work yet

3 files changed, 150 insertions, 31 deletions

diff --git a/src/bun.js/bindings/Process.cpp b/src/bun.js/bindings/Process.cpp
index 6209f13c5..376959241 100644
--- a/src/bun.js/bindings/Process.cpp
+++ b/src/bun.js/bindings/Process.cpp
@@ -74,6 +74,41 @@ JSC_DEFINE_CUSTOM_GETTER(
     Process_lazyStdinGetter,
     (JSGlobalObject * globalObject, EncodedJSValue thisValue, PropertyName property))
 {
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSC::JSValue value = JSC::JSValue::decode(thisValue);
+    if (!value || value.isUndefinedOrNull() || !value.isObject())
+        return JSValue::encode(jsUndefined());
+
+    auto* thisObject = reinterpret_cast<Zig::GlobalObject*>(globalObject);
+    JSC::JSFunction* getStdioWriteStream = JSC::JSFunction::create(vm, processObjectInternalsGetStdinStreamCodeGenerator(vm), globalObject);
+    JSC::MarkedArgumentBuffer args;
+    WTF::String process = WTF::String("node:process"_s);
+    JSC::JSValue requireFunction = Zig::ImportMetaObject::createRequireFunction(
+        vm,
+        globalObject,
+        process);
+
+    args.append(JSC::jsNumber(STDIN_FILENO));
+    args.append(requireFunction);
+    args.append(thisObject->get(globalObject, PropertyName(JSC::Identifier::fromString(vm, "Bun"_s))));
+
+    auto clientData = WebCore::clientData(vm);
+    JSC::CallData callData = JSC::getCallData(getStdioWriteStream);
+
+    NakedPtr<JSC::Exception> returnedException = nullptr;
+    auto result = JSC::call(globalObject, getStdioWriteStream, callData, globalObject->globalThis(), args, returnedException);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (UNLIKELY(returnedException)) {
+        throwException(globalObject, scope, returnedException.get());
+        return {};
+    }
+
+    if (LIKELY(result))
+        value.getObject()->putDirect(vm, property, result, 0);
+
+    return JSValue::encode(result);
 }
 
 JSC_DEFINE_CUSTOM_GETTER(
@@ -367,6 +402,93 @@ JSC_DEFINE_CUSTOM_SETTER(Process_setterRelease,
     return true;
 }
 
+static const NeverDestroyed<String> signalNames[] = {
+    MAKE_STATIC_STRING_IMPL("SIGHUP"),
+    MAKE_STATIC_STRING_IMPL("SIGINT"),
+    MAKE_STATIC_STRING_IMPL("SIGQUIT"),
+    MAKE_STATIC_STRING_IMPL("SIGILL"),
+    MAKE_STATIC_STRING_IMPL("SIGTRAP"),
+    MAKE_STATIC_STRING_IMPL("SIGABRT"),
+    MAKE_STATIC_STRING_IMPL("SIGIOT"),
+    MAKE_STATIC_STRING_IMPL("SIGBUS"),
+    MAKE_STATIC_STRING_IMPL("SIGFPE"),
+    MAKE_STATIC_STRING_IMPL("SIGKILL"),
+    MAKE_STATIC_STRING_IMPL("SIGUSR1"),
+    MAKE_STATIC_STRING_IMPL("SIGSEGV"),
+    MAKE_STATIC_STRING_IMPL("SIGUSR2"),
+    MAKE_STATIC_STRING_IMPL("SIGPIPE"),
+    MAKE_STATIC_STRING_IMPL("SIGALRM"),
+    MAKE_STATIC_STRING_IMPL("SIGTERM"),
+    MAKE_STATIC_STRING_IMPL("SIGCHLD"),
+    MAKE_STATIC_STRING_IMPL("SIGCONT"),
+    MAKE_STATIC_STRING_IMPL("SIGSTOP"),
+    MAKE_STATIC_STRING_IMPL("SIGTSTP"),
+    MAKE_STATIC_STRING_IMPL("SIGTTIN"),
+    MAKE_STATIC_STRING_IMPL("SIGTTOU"),
+    MAKE_STATIC_STRING_IMPL("SIGURG"),
+    MAKE_STATIC_STRING_IMPL("SIGXCPU"),
+    MAKE_STATIC_STRING_IMPL("SIGXFSZ"),
+    MAKE_STATIC_STRING_IMPL("SIGVTALRM"),
+    MAKE_STATIC_STRING_IMPL("SIGPROF"),
+    MAKE_STATIC_STRING_IMPL("SIGWINCH"),
+    MAKE_STATIC_STRING_IMPL("SIGIO"),
+    MAKE_STATIC_STRING_IMPL("SIGINFO"),
+    MAKE_STATIC_STRING_IMPL("SIGSYS"),
+};
+static const int signalNumbers[] = {
+    SIGHUP,
+    SIGINT,
+    SIGQUIT,
+    SIGILL,
+    SIGTRAP,
+    SIGABRT,
+    SIGIOT,
+    SIGBUS,
+    SIGFPE,
+    SIGKILL,
+    SIGUSR1,
+    SIGSEGV,
+    SIGUSR2,
+    SIGPIPE,
+    SIGALRM,
+    SIGTERM,
+    SIGCHLD,
+    SIGCONT,
+    SIGSTOP,
+    SIGTSTP,
+    SIGTTIN,
+    SIGTTOU,
+    SIGURG,
+    SIGXCPU,
+    SIGXFSZ,
+    SIGVTALRM,
+    SIGPROF,
+    SIGWINCH,
+    SIGIO,
+    SIGINFO,
+    SIGSYS,
+};
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionProcessOn, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (callFrame->argumentCount() < 2) {
+        throwVMError(globalObject, scope, "Not enough arguments"_s);
+        return JSValue::encode(jsUndefined());
+    }
+
+    String eventName = callFrame->uncheckedArgument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+}
+
+Process::~Process()
+{
+    for (auto& listener : this->wrapped().eventListenerMap().entries()) {
+    }
+}
+
 void Process::finishCreation(JSC::VM& vm)
 {
     Base::finishCreation(vm);
@@ -473,6 +595,9 @@ void Process::finishCreation(JSC::VM& vm)
 
     this->putDirectCustomAccessor(vm, JSC::PropertyName(JSC::Identifier::fromString(vm, "stderr"_s)),
         JSC::CustomGetterSetter::create(vm, Process_lazyStderrGetter, Process_defaultSetter), 0);
+
+    this->putDirectCustomAccessor(vm, JSC::PropertyName(JSC::Identifier::fromString(vm, "stdin"_s)),
+        JSC::CustomGetterSetter::create(vm, Process_lazyStdinGetter, Process_defaultSetter), 0);
 }
 
 const JSC::ClassInfo Process::s_info = { "Process"_s, &Base::s_info, nullptr, nullptr,
diff --git a/src/bun.js/builtins/cpp/ProcessObjectInternalsBuiltins.cpp b/src/bun.js/builtins/cpp/ProcessObjectInternalsBuiltins.cpp
index 07086c4c8..0170d0de3 100644
--- a/src/bun.js/builtins/cpp/ProcessObjectInternalsBuiltins.cpp
+++ b/src/bun.js/builtins/cpp/ProcessObjectInternalsBuiltins.cpp
@@ -473,7 +473,7 @@ const char* const s_processObjectInternalsGetStdioWriteStreamCode =
 const JSC::ConstructAbility s_processObjectInternalsGetStdinStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_processObjectInternalsGetStdinStreamCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_processObjectInternalsGetStdinStreamCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_processObjectInternalsGetStdinStreamCodeLength = 3915;
+const int s_processObjectInternalsGetStdinStreamCodeLength = 3786;
 static const JSC::Intrinsic s_processObjectInternalsGetStdinStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_processObjectInternalsGetStdinStreamCode =
     "(function (fd, rawRequire, Bun) {\n" \
@@ -505,7 +505,7 @@ const char* const s_processObjectInternalsGetStdinStreamCode =
     "    constructor() {\n" \
     "      super({ readable: true, writable: true });\n" \
     "\n" \
-    "      this.#onReadable = this._read.bind(this);\n" \
+    "      this.#onReadable = (...args) => this._read(...args);\n" \
     "    }\n" \
     "\n" \
     "    #onFinished(err) {\n" \
@@ -565,11 +565,10 @@ const char* const s_processObjectInternalsGetStdinStreamCode =
     "        Bun.stdin.stream(),\n" \
     "      ));\n" \
     "\n" \
-    "      readStream.on(\"readable\", () => {\n" \
-    "        const cb = this.#onReadable;\n" \
-    "        this.#onReadable = null;\n" \
-    "        cb();\n" \
+    "      readStream.on(\"data\", (data) => {\n" \
+    "        this.push(data);\n" \
     "      });\n" \
+    "      readStream.ref();\n" \
     "\n" \
     "      readStream.on(\"end\", () => {\n" \
     "        this.push(null);\n" \
@@ -584,16 +583,14 @@ const char* const s_processObjectInternalsGetStdinStreamCode =
     "      });\n" \
     "    }\n" \
     "\n" \
-    "    _read() {\n" \
-    "      var readStream = this.#readStream;\n" \
-    "      while (true) {\n" \
-    "        const buf = readStream.read();\n" \
-    "        if (buf === null || !this.push(buf)) {\n" \
-    "          this.#onReadable = this._read.bind(this);\n" \
-    "          return;\n" \
-    "        }\n" \
-    "      }\n" \
+    "    ref() {\n" \
+    "      this.#readStream?.ref?.();\n" \
     "    }\n" \
+    "    unref() {\n" \
+    "      this.#readStream?.unref?.();\n" \
+    "    }\n" \
+    "\n" \
+    "    _read(encoding, callback) {}\n" \
     "\n" \
     "    #constructWriteStream() {\n" \
     "      var { createWriteStream } = require(\"node:fs\");\n" \
@@ -641,7 +638,7 @@ const char* const s_processObjectInternalsGetStdinStreamCode =
     "\n" \
     "    _final(callback) {\n" \
     "      this.#writeStream.end();\n" \
-    "      this.#onFinish = callback.bind(this);\n" \
+    "      this.#onFinish = (...args) => callback(...args);\n" \
     "    }\n" \
     "  };\n" \
     "\n" \
diff --git a/src/bun.js/builtins/js/ProcessObjectInternals.js b/src/bun.js/builtins/js/ProcessObjectInternals.js
index 13c1da431..bf548eee6 100644
--- a/src/bun.js/builtins/js/ProcessObjectInternals.js
+++ b/src/bun.js/builtins/js/ProcessObjectInternals.js
@@ -464,7 +464,7 @@ function getStdinStream(fd, rawRequire, Bun) {
     constructor() {
       super({ readable: true, writable: true });
 
-      this.#onReadable = this._read.bind(this);
+      this.#onReadable = (...args) => this._read(...args);
     }
 
     #onFinished(err) {
@@ -522,11 +522,10 @@ function getStdinStream(fd, rawRequire, Bun) {
         Bun.stdin.stream(),
       ));
 
-      readStream.on("readable", () => {
-        const cb = this.#onReadable;
-        this.#onReadable = null;
-        cb();
+      readStream.on("data", (data) => {
+        this.push(data);
       });
+      readStream.ref();
 
       readStream.on("end", () => {
         this.push(null);
@@ -541,16 +540,14 @@ function getStdinStream(fd, rawRequire, Bun) {
       });
     }
 
-    _read() {
-      var readStream = this.#readStream;
-      while (true) {
-        const buf = readStream.read();
-        if (buf === null || !this.push(buf)) {
-          this.#onReadable = this._read.bind(this);
-          return;
-        }
-      }
+    ref() {
+      this.#readStream?.ref?.();
     }
+    unref() {
+      this.#readStream?.unref?.();
+    }
+
+    _read(encoding, callback) {}
 
     #constructWriteStream() {
       var { createWriteStream } = require("node:fs");
@@ -598,7 +595,7 @@ function getStdinStream(fd, rawRequire, Bun) {
 
     _final(callback) {
       this.#writeStream.end();
-      this.#onFinish = callback.bind(this);
+      this.#onFinish = (...args) => callback(...args);
     }
   };