Add new PTY node (replaces Pseudoterminal node)

Uses fork of node-pty native code for forking pseudoterminals.
Uses libuv pipe handle to communicate with the child process.

- Paves the way for cross-platform (Linux, macOS and Windows) support.
- Renames Pseudoterminal to PTY (which is much easier to type and spell :D).
- Better performance than the old Pseudoterminal node. Especially when
  streaming large amounts of data such as running the `yes` command.
- Allows setting custom file, args, initial window size, cwd, env vars
  (including important ones such as TERM and COLORTERM) and uid/gid
  on Linux and macOS.
- Returns process exit code and terminating signal.

.github/workflows/main.yml

@@ -46,6 +46,18 @@ jobs:
         with:
           path: addons/godot_xterm/native/thirdparty/godot-cpp
           key: godot-cpp-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.bits }}-${{ env.GODOT_CPP_COMMIT_HASH }}
+      - name: Get libuv submodule commit hash
+        shell: bash
+        env:
+          ACTIONS_ALLOW_UNSECURE_COMMANDS: true
+        run: |
+          echo ::set-env name=LIBUV_COMMIT_HASH::$(git ls-tree HEAD addons/godot_xterm/native/thirdparty/libuv -l | cut -d\  -f3)
+      - name: Cache libuv
+        uses: actions/cache@v2
+        id: cache-libuv
+        with:
+          path: addons/godot_xterm/native/thirdparty/libuv
+          key: libuv-cache-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.bits }}-${{ env.LIBUV_COMMIT_HASH }}
       - name: Cache emscripten
         if: ${{ matrix.platform == 'javascript' }}
         uses: actions/cache@v2
@@ -86,6 +98,25 @@ jobs:
           cd addons/godot_xterm/native/thirdparty/godot-cpp
           scons platform=${{ matrix.platform }} target=${{ matrix.target }} bits=${{ matrix.bits }} generate_bindings=yes -j2
 
+      - name: Build libuv 
+        if: ${{ matrix.bits == 64 && steps.cache-libuv.outputs.cache-hit != 'true' }} 
+        uses: lukka/run-cmake@v3
+        with:
+          cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+          cmakeListsTxtPath: '${{ github.workspace }}/addons/godot_xterm/native/thirdparty/libuv/CMakeLists.txt'
+          useVcpkgToolchainFile: true
+          cmakeAppendedArgs: '-DCMAKE_BUILD_TYPE=${{ matrix.target }} -DBUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE'
+          buildDirectory: '${{ github.workspace }}/addons/godot_xterm/native/thirdparty/libuv/build'
+      - name: Build libuv 32 bit
+        if: ${{ matrix.bits == 32 && steps.cache-libuv.outputs.cache-hit != 'true' }} 
+        uses: lukka/run-cmake@v3
+        with:
+          cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+          cmakeListsTxtPath: '${{ github.workspace }}/addons/godot_xterm/native/thirdparty/libuv/CMakeLists.txt'
+          useVcpkgToolchainFile: true
+          cmakeAppendedArgs: '-DCMAKE_BUILD_TYPE=${{ matrix.target }} -DBUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -DCMAKE_SYSTEM_PROCESSOR=i686 -DCMAKE_C_FLAGS=-m32'
+          buildDirectory: '${{ github.workspace }}/addons/godot_xterm/native/thirdparty/libuv/build'
+
       - name: Build libgodot-xterm
         run: |
           cd addons/godot_xterm/native

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "misc/export_templates/godot"]
 	path = misc/export_templates/godot
 	url = https://github.com/godotengine/godot
+[submodule "addons/godot_xterm/native/thirdparty/libuv"]
+	path = addons/godot_xterm/native/thirdparty/libuv
+	url = https://github.com/libuv/libuv

.gutconfig.json

@@ -1,20 +1,8 @@
 {
-  "dirs": [ "res://test" ],
+  "dirs": [
-  "disable_colors": false,
+    "res://"
-  "double_strategy": "partial",
+  ],
-  "ignore_pause": false,
+  "prefix": "",
-  "include_subdirs": true,
+  "suffix": ".test.gd",
-  "inner_class": "",
+  "include_subdirs": true
-  "log_level": 1,
-  "opacity": 100,
-  "post_run_script": "",
-  "pre_run_script": "",
-  "prefix": "test_",
-  "selected": "",
-  "should_exit": true,
-  "should_exit_on_success": false,
-  "should_maximize": false,
-  "suffix": ".gd",
-  "tests": [],
-  "unit_test_name": ""
 }

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Leroy Hopson and [contributors](https://github.com/lihop/godot-xterm/contributors)
+Copyright (c) 2020-2021, Leroy Hopson and [contributors](https://github.com/lihop/godot-xterm/contributors)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

addons/godot_xterm/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Leroy Hopson and [contributors](https://github.com/lihop/godot-xterm/contributors)
+Copyright (c) 2020-2021, Leroy Hopson and [contributors](https://github.com/lihop/godot-xterm/contributors)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

addons/godot_xterm/native/SConstruct

@@ -218,10 +218,13 @@ env.Append(CXXFLAGS=['-std=c++14'])
 env.Append(CPPPATH=[
     'src/',
     'thirdparty/libtsm/build/src/tsm',
+    'thirdparty/libtsm/build/src/shared',
     'thirdparty/godot-cpp/include/',
     'thirdparty/godot-cpp/include/core/',
     'thirdparty/godot-cpp/include/gen/',
-    'thirdparty/godot-cpp/godot-headers/'
+    'thirdparty/godot-cpp/godot-headers/',
+    'thirdparty/libuv/src',
+    'thirdparty/libuv/include'
 ])
 env.Append(LIBPATH=[
     'thirdparty/godot-cpp/bin/',
@@ -247,10 +250,12 @@ sources = []
 sources.append('src/libgodotxtermnative.cpp')
 sources.append('src/terminal.cpp')
 
-# Psuedoterminal not supported on windows (yet) or HTML5.
+# PTY not supported on HTML5 or Windows (yet).
-if env['platform'] != 'windows' and env['platform'] != 'javascript':
+if env['platform'] != 'javascript' and env['platform'] != 'windows':
-    sources.append('src/pseudoterminal.cpp')
+    sources.append('src/pipe.cpp')
-    env.Append(LIBS=['util'])
+    sources.append('src/libuv_utils.cpp')
+    sources.append('src/node_pty/unix/pty.cc')
+    env.Append(LIBS=['util', env.File('thirdparty/libuv/build/libuv_a.a')])
 
 if env['platform'] == 'linux':
     libsuffix = "a"

addons/godot_xterm/native/build.sh

@@ -15,21 +15,32 @@ fi
 
 
 # Update git submodules.
-LIBTSM_DIR=${NATIVE_DIR}/thirdparty/libtsm
+updateSubmodules() {
-if [ -z "$(ls -A -- "$LIBTSM_DIR")" ]; then
+	eval $1=$2 # E.g LIBUV_DIR=${NATIVE_DIR}/thirdparty/libuv
+
+	if [ -z "$(ls -A -- "$2")" ]; then
 		cd ${NATIVE_DIR}
-	git submodule update --init --recursive -- $LIBTSM_DIR
+		git submodule update --init --recursive -- $2
-fi
+	fi
-GODOT_CPP_DIR=${NATIVE_DIR}/thirdparty/godot-cpp
+}
-if [ -z "$(ls -A -- "$GODOT_CPP_DIR")" ]; then
+
-	cd ${NATIVE_DIR}
+updateSubmodules LIBUV_DIR ${NATIVE_DIR}/thirdparty/libuv
-	git submodule update --init --recursive -- $GODOT_CPP_DIR
+updateSubmodules LIBTSM_DIR ${NATIVE_DIR}/thirdparty/libtsm 
-fi
+updateSubmodules GODOT_CPP_DIR ${NATIVE_DIR}/thirdparty/godot-cpp
+
 
 # Build godot-cpp bindings.
 cd ${GODOT_CPP_DIR}
 scons generate_bindings=yes target=debug -j$(nproc)
 
+# Build libuv as a static library.
+cd ${LIBUV_DIR}
+mkdir build || true
+cd build
+cmake .. -DCMAKE_BUILD_TYPE=debug -DBUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE
+cd ..
+cmake --build build -j$(nproc)
+
 # Build libgodot-xterm.
 cd ${NATIVE_DIR}
 scons target=debug -j$(nproc)

addons/godot_xterm/native/shell.nix

@@ -6,6 +6,9 @@ mkShell {
 
     cacert # Required for git clone on GithHub actions runner.
 
+    # Used to build libuv.
+    cmake
+
     # Used to build for javascript platform.
     docker
     docker-compose

addons/godot_xterm/native/src/libgodotxtermnative.cpp

@@ -1,6 +1,9 @@
 #include "terminal.h"
-#if defined(__unix__) /* Linux and macOS */ && !defined(__EMSCRIPTEN__)
+
-#include "pseudoterminal.h"
+#if !defined(__EMSCRIPTEN__) && !defined(__WIN32)
+#include "libuv_utils.h"
+#include "node_pty/unix/pty.h"
+#include "pipe.h"
 #endif
 
 extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
@@ -14,9 +17,10 @@ godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
 
 extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
   godot::Godot::nativescript_init(handle);
-
   godot::register_tool_class<godot::Terminal>();
-#if defined(__unix__) && !defined(__EMSCRIPTEN__)
+#if !defined(__EMSCRIPTEN__) && !defined(__WIN32)
-  godot::register_class<godot::Pseudoterminal>();
+  godot::register_tool_class<godot::Pipe>();
+  godot::register_tool_class<godot::LibuvUtils>();
+  godot::register_tool_class<godot::PTYUnix>();
 #endif
 }

addons/godot_xterm/native/src/libuv_utils.cpp

@@ -0,0 +1,190 @@
+#include "libuv_utils.h"
+#include <uv.h>
+
+using namespace godot;
+
+void LibuvUtils::_register_methods() {
+  register_method("_init", &LibuvUtils::_init);
+
+  register_method("get_os_environ", &LibuvUtils::get_os_environ);
+  register_method("get_os_release", &LibuvUtils::get_os_release);
+  register_method("get_cwd", &LibuvUtils::get_cwd);
+}
+
+LibuvUtils::LibuvUtils() {}
+LibuvUtils::~LibuvUtils() {}
+
+void LibuvUtils::_init() {}
+
+Dictionary LibuvUtils::get_os_environ() {
+  Dictionary result;
+
+  uv_env_item_t *env;
+  int count;
+  uv_os_environ(&env, &count);
+
+  for (int i = 0; i < count; i++) {
+    result[String(env[i].name)] = String(env[i].value);
+  }
+
+  uv_os_free_environ(env, count);
+
+  return result;
+}
+
+String LibuvUtils::get_os_release() { return "TODO"; }
+
+String LibuvUtils::get_cwd() {
+#ifndef PATH_MAX
+#define PATH_MAX MAX_PATH
+#endif
+  size_t size = PATH_MAX;
+  char *buffer = (char *)malloc(size * sizeof(char));
+  int err;
+
+  err = uv_cwd(buffer, &size);
+
+  if (err == UV_ENOBUFS) {
+    // Buffer was too small. `size` has been set to the required length, so
+    // resize buffer and try again.
+    buffer = (char *)realloc(buffer, size * sizeof(char));
+    err = uv_cwd(buffer, &size);
+  }
+
+  if (err < 0) {
+    UV_ERR_PRINT(err);
+    return "";
+  }
+
+  String result = String(buffer);
+  std::free(buffer);
+  return result;
+}
+
+godot_error LibuvUtils::translate_uv_errno(int uv_err) {
+  if (uv_err >= 0)
+    return GODOT_OK;
+
+  // Rough translation of libuv error to godot error.
+  // Not necessarily accurate.
+
+  switch (uv_err) {
+  case UV_EEXIST: // file already exists
+    return GODOT_ERR_ALREADY_EXISTS;
+
+  case UV_EADDRINUSE: // address already in use
+    return GODOT_ERR_ALREADY_IN_USE;
+
+  case UV_EBUSY:   // resource busy or locked
+  case UV_ETXTBSY: // text file is busy
+    return GODOT_ERR_BUSY;
+
+  case UV_ECONNREFUSED: // connection refused
+    return GODOT_ERR_CANT_CONNECT;
+
+  case UV_ECONNABORTED: // software caused connection abort
+  case UV_ECONNRESET:   // connection reset by peer
+  case UV_EISCONN:      // socket is already connected
+  case UV_ENOTCONN:     // socket is not connected
+    return GODOT_ERR_CONNECTION_ERROR;
+
+  case UV_ENODEV: // no such device
+  case UV_ENXIO:  // no such device or address
+  case UV_ESRCH:  // no such process
+    return GODOT_ERR_DOES_NOT_EXIST;
+
+  case UV_EROFS: // read-only file system
+    return GODOT_ERR_FILE_CANT_WRITE;
+
+  case UV_EOF: // end of file
+    return GODOT_ERR_FILE_EOF;
+
+  case UV_ENOENT: // no such file or directory
+    return GODOT_ERR_FILE_NOT_FOUND;
+
+  case UV_EAI_BADFLAGS:                 // bad ai_flags value
+  case UV_EAI_BADHINTS:                 // invalid value for hints
+  case UV_EFAULT:                       // bad address in system call argument
+  case UV_EFTYPE:                       // inappropriate file type or format
+  case UV_EINVAL:                       // invalid argument
+  case UV_ENOTTY:                       // inappropriate ioctl for device
+  case UV_EPROTOTYPE:                   // protocol wrong type for socket
+    return GODOT_ERR_INVALID_PARAMETER; // Parameter passed is invalid
+
+  case UV_ENOSYS: // function not implemented
+    return GODOT_ERR_METHOD_NOT_FOUND;
+
+  case UV_EAI_MEMORY: // out of memory
+    return GODOT_ERR_OUT_OF_MEMORY;
+
+  case UV_E2BIG:        // argument list too long
+  case UV_EFBIG:        // file too large
+  case UV_EMSGSIZE:     // message too long
+  case UV_ENAMETOOLONG: // name too long
+  case UV_EOVERFLOW:    // value too large for defined data type
+  case UV_ERANGE:       // result too large
+    return GODOT_ERR_PARAMETER_RANGE_ERROR; // Parameter given out of range
+
+  case UV_ETIMEDOUT:
+    return GODOT_ERR_TIMEOUT; // connection timed out
+
+  case UV_EACCES: // permission denied
+  case UV_EPERM:  // operation not permitted
+  case UV_EXDEV:  // cross-device link not permitted
+    return GODOT_ERR_UNAUTHORIZED;
+
+  case UV_EADDRNOTAVAIL:          // address not available
+  case UV_EAFNOSUPPORT:           // address family not supported
+  case UV_EAGAIN:                 // resource temporarily unavailable
+  case UV_EAI_ADDRFAMILY:         // address family not supported
+  case UV_EAI_FAMILY:             // ai_family not supported
+  case UV_EAI_SERVICE:            // service not available for socket type
+  case UV_EAI_SOCKTYPE:           // socket type not supported
+  case UV_ENOPROTOOPT:            // protocol not available
+  case UV_ENOTSUP:                // operation not supported on socket
+  case UV_EPROTONOSUPPORT:        // protocol not supported
+  case UV_ESOCKTNOSUPPORT:        // socket type not supported
+    return GODOT_ERR_UNAVAILABLE; // What is requested is
+                                  // unsupported/unavailable
+
+  case UV_EAI_NODATA:   // no address
+  case UV_EDESTADDRREQ: // destination address required
+    return GODOT_ERR_UNCONFIGURED;
+
+  case UV_EAI_AGAIN:    // temporary failure
+  case UV_EAI_CANCELED: // request canceled
+  case UV_EAI_FAIL:     // permanent failure
+  case UV_EAI_NONAME:   // unknown node or service
+  case UV_EAI_OVERFLOW: // argument buffer overflow
+  case UV_EAI_PROTOCOL: // resolved protocol is unknown
+  case UV_EALREADY:     // connection already in progress
+  case UV_EBADF:        // bad file descriptor
+  case UV_ECANCELED:    // operation canceled
+  case UV_ECHARSET:     // invalid Unicode character
+  case UV_EHOSTUNREACH: // host is unreachable
+  case UV_EIO:          // i/o error
+  case UV_EILSEQ:       // illegal byte sequence
+  case UV_EISDIR:       // illegal operation on a directory
+  case UV_ELOOP:        // too many symbolic links encountered
+  case UV_EMFILE:       // too many open files
+  case UV_ENETDOWN:     // network is down
+  case UV_ENETUNREACH:  // network is unreachable
+  case UV_ENFILE:       // file table overflow
+  case UV_ENOBUFS:      // no buffer space available
+  case UV_ENOMEM:       // not enough memory
+  case UV_ESHUTDOWN:    // cannot send after transport endpoint shutdown
+  case UV_EINTR:        // interrupted system call
+  case UV_EMLINK:       // too many links
+  case UV_ENONET:       // machine is not on the network
+  case UV_ENOSPC:       // no space left on device
+  case UV_ENOTDIR:      // not a directory
+  case UV_ENOTEMPTY:    // directory not empty
+  case UV_ENOTSOCK:     // socket operation on non-socket
+  case UV_EPIPE:        // broken pipe
+  case UV_EPROTO:       // protocol error
+  case UV_ESPIPE:       // invalid seek
+  case UV_UNKNOWN:      // unknown error
+  default:
+    return GODOT_FAILED; // Generic fail error
+  }
+}

addons/godot_xterm/native/src/libuv_utils.h

@@ -0,0 +1,43 @@
+#ifndef GODOT_XTERM_UV_UTILS_H
+#define GODOT_XTERM_UV_UTILS_H
+
+#include <Godot.hpp>
+#include <uv.h>
+
+#define UV_ERR_PRINT(uv_err)                                                   \
+  ERR_PRINT(String(uv_err_name(uv_err)) + String(": ") +                       \
+            String(uv_strerror(uv_err)));
+
+#define RETURN_UV_ERR(uv_err)                                                  \
+  UV_ERR_PRINT(uv_err);                                                        \
+  return LibuvUtils::translate_uv_errno(uv_err);
+
+#define RETURN_IF_UV_ERR(uv_err)                                               \
+  if (uv_err < 0) {                                                            \
+    RETURN_UV_ERR(uv_err);                                                     \
+  }
+
+namespace godot {
+
+class LibuvUtils : public Reference {
+  GODOT_CLASS(LibuvUtils, Reference)
+
+public:
+  static void _register_methods();
+
+  LibuvUtils();
+  ~LibuvUtils();
+
+  void _init();
+
+  Dictionary get_os_environ();
+  String get_os_release();
+  String get_cwd();
+
+public:
+  static godot_error translate_uv_errno(int uv_err);
+};
+
+} // namespace godot
+
+#endif // GODOT_XTERM_UV_UTILS_H

addons/godot_xterm/native/src/node_pty/LICENSE.md

@@ -1,5 +1,7 @@
 The code under the `node_pty` directory is taken from the [node-pty project](https://github.com/microsoft/node-pty), which in turn contains code from the [Tmux project](http://tmux.sourceforge.net/).
 
+The code has been modified to remove references to node/V8 and make it compatible with GDNative. Any copyrightable modifications are released under the [same license](/addons/godot_xterm/LICENSE) as the rest of the GodotXterm project.
+
 ### Node-pty License
 
 ```

addons/godot_xterm/native/src/node_pty/unix/pty.cc

@@ -1,6 +1,7 @@
 /**
  * Copyright (c) 2012-2015, Christopher Jeffrey (MIT License)
  * Copyright (c) 2017, Daniel Imms (MIT License)
+ * Copyright (c) 2021, Leroy Hopson (MIT License)
  *
  * pty.cc:
  *   This file is responsible for starting processes
@@ -17,8 +18,12 @@
  * Includes
  */
 
+#include "pty.h"
+#include "libuv_utils.h"
+#include <FuncRef.hpp>
+#include <uv.h>
+
 #include <errno.h>
-#include <nan.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -77,12 +82,14 @@ extern char **environ;
 #define NSIG 32
 #endif
 
+using namespace godot;
+
 /**
  * Structs
  */
 
 struct pty_baton {
-  Nan::Persistent<v8::Function> cb;
+  Ref<FuncRef> cb;
   int exit_code;
   int signal_code;
   pid_t pid;
@@ -90,15 +97,6 @@ struct pty_baton {
   uv_thread_t tid;
 };
 
-/**
- * Methods
- */
-
-NAN_METHOD(PtyFork);
-NAN_METHOD(PtyOpen);
-NAN_METHOD(PtyResize);
-NAN_METHOD(PtyGetProc);
-
 /**
  * Functions
  */
@@ -121,52 +119,41 @@ static void pty_after_waitpid(uv_async_t *);
 
 static void pty_after_close(uv_handle_t *);
 
-NAN_METHOD(PtyFork) {
+Array PTYUnix::fork(String p_file, int _ignored, PoolStringArray p_args,
-  Nan::HandleScope scope;
+                    PoolStringArray p_env, String p_cwd, int p_cols, int p_rows,
-
+                    int p_uid, int p_gid, bool p_utf8, Ref<FuncRef> p_on_exit) {
-  if (info.Length() != 10 || !info[0]->IsString() || !info[1]->IsArray() ||
-      !info[2]->IsArray() || !info[3]->IsString() || !info[4]->IsNumber() ||
-      !info[5]->IsNumber() || !info[6]->IsNumber() || !info[7]->IsNumber() ||
-      !info[8]->IsBoolean() || !info[9]->IsFunction()) {
-    return Nan::ThrowError("Usage: pty.fork(file, args, env, cwd, cols, rows, "
-                           "uid, gid, utf8, onexit)");
-  }
-
   // file
-  Nan::Utf8String file(info[0]);
+  char *file = p_file.alloc_c_string();
 
   // args
   int i = 0;
-  v8::Local<v8::Array> argv_ = v8::Local<v8::Array>::Cast(info[1]);
+  int argc = p_args.size();
-  int argc = argv_->Length();
   int argl = argc + 1 + 1;
   char **argv = new char *[argl];
-  argv[0] = strdup(*file);
+  argv[0] = strdup(file);
   argv[argl - 1] = NULL;
   for (; i < argc; i++) {
-    Nan::Utf8String arg(Nan::Get(argv_, i).ToLocalChecked());
+    char *arg = p_args[i].alloc_c_string();
-    argv[i + 1] = strdup(*arg);
+    argv[i + 1] = strdup(arg);
   }
 
   // env
   i = 0;
-  v8::Local<v8::Array> env_ = v8::Local<v8::Array>::Cast(info[2]);
+  int envc = p_env.size();
-  int envc = env_->Length();
   char **env = new char *[envc + 1];
   env[envc] = NULL;
   for (; i < envc; i++) {
-    Nan::Utf8String pair(Nan::Get(env_, i).ToLocalChecked());
+    char *pairs = p_env[i].alloc_c_string();
-    env[i] = strdup(*pair);
+    env[i] = strdup(pairs);
   }
 
   // cwd
-  Nan::Utf8String cwd_(info[3]);
+  char *cwd = strdup(p_cwd.alloc_c_string());
-  char *cwd = strdup(*cwd_);
 
   // size
   struct winsize winp;
-  winp.ws_col = info[4]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  winp.ws_col = p_cols;
-  winp.ws_row = info[5]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  winp.ws_row = p_rows;
   winp.ws_xpixel = 0;
   winp.ws_ypixel = 0;
 
@@ -174,7 +161,7 @@ NAN_METHOD(PtyFork) {
   struct termios t = termios();
   struct termios *term = &t;
   term->c_iflag = ICRNL | IXON | IXANY | IMAXBEL | BRKINT;
-  if (Nan::To<bool>(info[8]).FromJust()) {
+  if (p_utf8) {
 #if defined(IUTF8)
     term->c_iflag |= IUTF8;
 #endif
@@ -210,8 +197,8 @@ NAN_METHOD(PtyFork) {
   cfsetospeed(term, B38400);
 
   // uid / gid
-  int uid = info[6]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  int uid = p_uid;
-  int gid = info[7]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  int gid = p_gid;
 
   // fork the pty
   int master = -1;
@@ -242,17 +229,18 @@ NAN_METHOD(PtyFork) {
 
   if (pid) {
     for (i = 0; i < argl; i++)
-      free(argv[i]);
+      std::free(argv[i]);
     delete[] argv;
     for (i = 0; i < envc; i++)
-      free(env[i]);
+      std::free(env[i]);
     delete[] env;
-    free(cwd);
+    std::free(cwd);
   }
 
   switch (pid) {
   case -1:
-    return Nan::ThrowError("forkpty(3) failed.");
+    ERR_PRINT("forkpty(3) failed.");
+    return Array::make(GODOT_FAILED);
   case 0:
     if (strlen(cwd)) {
       if (chdir(cwd) == -1) {
@@ -278,21 +266,19 @@ NAN_METHOD(PtyFork) {
     _exit(1);
   default:
     if (pty_nonblock(master) == -1) {
-      return Nan::ThrowError("Could not set master fd to nonblocking.");
+      ERR_PRINT("Could not set master fd to nonblocking.");
+      return Array::make(GODOT_FAILED);
     }
 
-    v8::Local<v8::Object> obj = Nan::New<v8::Object>();
+    Dictionary result = Dictionary::make();
-    Nan::Set(obj, Nan::New<v8::String>("fd").ToLocalChecked(),
+    result["fd"] = (int)master;
-             Nan::New<v8::Number>(master));
+    result["pid"] = (int)pid;
-    Nan::Set(obj, Nan::New<v8::String>("pid").ToLocalChecked(),
+    result["pty"] = ptsname(master);
-             Nan::New<v8::Number>(pid));
-    Nan::Set(obj, Nan::New<v8::String>("pty").ToLocalChecked(),
-             Nan::New<v8::String>(ptsname(master)).ToLocalChecked());
 
     pty_baton *baton = new pty_baton();
     baton->exit_code = 0;
     baton->signal_code = 0;
-    baton->cb.Reset(v8::Local<v8::Function>::Cast(info[9]));
+    baton->cb = p_on_exit;
     baton->pid = pid;
     baton->async.data = baton;
 
@@ -300,23 +286,17 @@ NAN_METHOD(PtyFork) {
 
     uv_thread_create(&baton->tid, pty_waitpid, static_cast<void *>(baton));
 
-    return info.GetReturnValue().Set(obj);
+    return Array::make(GODOT_OK, result);
   }
 
-  return info.GetReturnValue().SetUndefined();
+  return Array::make(GODOT_FAILED);
 }
 
-NAN_METHOD(PtyOpen) {
+Array PTYUnix::open(int p_cols, int p_rows) {
-  Nan::HandleScope scope;
-
-  if (info.Length() != 2 || !info[0]->IsNumber() || !info[1]->IsNumber()) {
-    return Nan::ThrowError("Usage: pty.open(cols, rows)");
-  }
-
   // size
   struct winsize winp;
-  winp.ws_col = info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  winp.ws_col = p_cols;
-  winp.ws_row = info[1]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  winp.ws_row = p_rows;
   winp.ws_xpixel = 0;
   winp.ws_ypixel = 0;
 
@@ -325,85 +305,72 @@ NAN_METHOD(PtyOpen) {
   int ret = pty_openpty(&master, &slave, nullptr, NULL, &winp);
 
   if (ret == -1) {
-    return Nan::ThrowError("openpty(3) failed.");
+    ERR_PRINT("openpty(3) failed.");
+    return Array::make(GODOT_FAILED);
   }
 
   if (pty_nonblock(master) == -1) {
-    return Nan::ThrowError("Could not set master fd to nonblocking.");
+    ERR_PRINT("Could not set master fd to nonblocking.");
+    return Array::make(GODOT_FAILED);
   }
 
   if (pty_nonblock(slave) == -1) {
-    return Nan::ThrowError("Could not set slave fd to nonblocking.");
+    ERR_PRINT("Could not set slave fd to nonblocking.");
+    return Array::make(GODOT_FAILED);
   }
 
-  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
+  Dictionary dict = Dictionary::make();
-  Nan::Set(obj, Nan::New<v8::String>("master").ToLocalChecked(),
+  dict["master"] = master;
-           Nan::New<v8::Number>(master));
+  dict["slave"] = slave;
-  Nan::Set(obj, Nan::New<v8::String>("slave").ToLocalChecked(),
+  dict["pty"] = ptsname(master);
-           Nan::New<v8::Number>(slave));
-  Nan::Set(obj, Nan::New<v8::String>("pty").ToLocalChecked(),
-           Nan::New<v8::String>(ptsname(master)).ToLocalChecked());
 
-  return info.GetReturnValue().Set(obj);
+  return Array::make(GODOT_OK, dict);
 }
 
-NAN_METHOD(PtyResize) {
+godot_error PTYUnix::resize(int p_fd, int p_cols, int p_rows) {
-  Nan::HandleScope scope;
+  int fd = p_fd;
-
-  if (info.Length() != 3 || !info[0]->IsNumber() || !info[1]->IsNumber() ||
-      !info[2]->IsNumber()) {
-    return Nan::ThrowError("Usage: pty.resize(fd, cols, rows)");
-  }
-
-  int fd = info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust();
 
   struct winsize winp;
-  winp.ws_col = info[1]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  winp.ws_col = p_cols;
-  winp.ws_row = info[2]->IntegerValue(Nan::GetCurrentContext()).FromJust();
+  winp.ws_row = p_rows;
   winp.ws_xpixel = 0;
   winp.ws_ypixel = 0;
 
   if (ioctl(fd, TIOCSWINSZ, &winp) == -1) {
     switch (errno) {
     case EBADF:
-      return Nan::ThrowError("ioctl(2) failed, EBADF");
+      RETURN_UV_ERR(UV_EBADF)
     case EFAULT:
-      return Nan::ThrowError("ioctl(2) failed, EFAULT");
+      RETURN_UV_ERR(UV_EFAULT)
     case EINVAL:
-      return Nan::ThrowError("ioctl(2) failed, EINVAL");
+      RETURN_UV_ERR(UV_EINVAL);
     case ENOTTY:
-      return Nan::ThrowError("ioctl(2) failed, ENOTTY");
+      RETURN_UV_ERR(UV_ENOTTY);
     }
-    return Nan::ThrowError("ioctl(2) failed");
+    ERR_PRINT("ioctl(2) failed");
+    return GODOT_FAILED;
   }
 
-  return info.GetReturnValue().SetUndefined();
+  return GODOT_OK;
 }
 
 /**
  * Foreground Process Name
  */
-NAN_METHOD(PtyGetProc) {
+String PTYUnix::process(int p_fd, String p_tty) {
-  Nan::HandleScope scope;
+  int fd = p_fd;
 
-  if (info.Length() != 2 || !info[0]->IsNumber() || !info[1]->IsString()) {
+  char *tty = p_tty.alloc_c_string();
-    return Nan::ThrowError("Usage: pty.process(fd, tty)");
-  }
-
-  int fd = info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust();
-
-  Nan::Utf8String tty_(info[1]);
-  char *tty = strdup(*tty_);
   char *name = pty_getproc(fd, tty);
-  free(tty);
+  std::free(tty);
 
   if (name == NULL) {
-    return info.GetReturnValue().SetUndefined();
+    return "";
   }
 
-  v8::Local<v8::String> name_ = Nan::New<v8::String>(name).ToLocalChecked();
+  String name_ = String(name);
-  free(name);
+  std::free(name);
-  return info.GetReturnValue().Set(name_);
+  return name_;
 }
 
 /**
@@ -453,7 +420,7 @@ static void pty_waitpid(void *data) {
       // waitpid is already handled elsewhere.
       ;
     } else {
-      assert(false);
+      // assert(false);
     }
   }
 
@@ -474,19 +441,12 @@ static void pty_waitpid(void *data) {
  */
 
 static void pty_after_waitpid(uv_async_t *async) {
-  Nan::HandleScope scope;
   pty_baton *baton = static_cast<pty_baton *>(async->data);
 
-  v8::Local<v8::Value> argv[] = {
+  Array argv = Array::make(baton->exit_code, baton->signal_code);
-      Nan::New<v8::Integer>(baton->exit_code),
-      Nan::New<v8::Integer>(baton->signal_code),
-  };
 
-  v8::Local<v8::Function> cb = Nan::New<v8::Function>(baton->cb);
+  ERR_FAIL_COND(baton->cb == nullptr);
-  baton->cb.Reset();
+  baton->cb->call_funcv(argv);
-  memset(&baton->cb, -1, sizeof(baton->cb));
-  Nan::AsyncResource resource("pty_after_waitpid");
-  resource.runInAsyncScope(Nan::GetCurrentContext()->Global(), cb, 2, argv);
 
   uv_close((uv_handle_t *)async, pty_after_close);
 }
@@ -701,12 +661,12 @@ static pid_t pty_forkpty(int *amaster, char *name, const struct termios *termp,
  * Init
  */
 
-NAN_MODULE_INIT(init) {
+void PTYUnix::_register_methods() {
-  Nan::HandleScope scope;
+  register_method("_init", &PTYUnix::_init);
-  Nan::Export(target, "fork", PtyFork);
+  register_method("fork", &PTYUnix::fork);
-  Nan::Export(target, "open", PtyOpen);
+  register_method("open", &PTYUnix::open);
-  Nan::Export(target, "resize", PtyResize);
+  register_method("resize", &PTYUnix::resize);
-  Nan::Export(target, "process", PtyGetProc);
+  register_method("process", &PTYUnix::process);
 }
 
-NODE_MODULE(pty, init)
+void PTYUnix::_init() {}

addons/godot_xterm/native/src/node_pty/unix/pty.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2021, Leroy Hopson (MIT License).
+
+#ifndef GODOT_XTERM_PTY_H
+#define GODOT_XTERM_PTY_H
+
+#include <FuncRef.hpp>
+#include <Godot.hpp>
+
+namespace godot {
+
+class PTYUnix : public Reference {
+  GODOT_CLASS(PTYUnix, Reference)
+
+public:
+  Array fork(String file,
+             int _ignored, /* FIXME: For some reason Pipe throws
+                       ENOTSOCK in read callback if args (or another non-empty,
+                       non-zero) value is in this position. */
+             PoolStringArray args, PoolStringArray env, String cwd, int cols,
+             int rows, int uid, int gid, bool utf8, Ref<FuncRef> on_exit);
+  Array open(int cols, int rows);
+  godot_error resize(int fd, int cols, int rows);
+  String process(int fd, String tty);
+
+  void _init();
+  static void _register_methods();
+};
+
+} // namespace godot
+
+#endif // GODOT_XTERM_PTY_H

addons/godot_xterm/native/src/pipe.cpp

@@ -0,0 +1,108 @@
+// Copyright (c) 2021, Leroy Hopson (MIT License).
+
+#include "pipe.h"
+#include "libuv_utils.h"
+#include <Dictionary.hpp>
+#include <InputEventKey.hpp>
+#include <OS.hpp>
+#include <ResourceLoader.hpp>
+#include <Theme.hpp>
+#include <Timer.hpp>
+#include <algorithm>
+#include <thread>
+#include <vector>
+#include <xkbcommon/xkbcommon-keysyms.h>
+
+using namespace godot;
+
+void Pipe::_register_methods() {
+  register_method("_init", &Pipe::_init);
+
+  register_method("poll", &Pipe::_poll_connection);
+  register_method("open", &Pipe::open);
+  register_method("write", &Pipe::write);
+
+  register_signal<Pipe>("data_received", "data",
+                        GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY);
+}
+
+Pipe::Pipe() {}
+Pipe::~Pipe() {}
+
+void Pipe::_init() {}
+
+void _poll_connection();
+
+void _read_cb(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf);
+
+void _write_cb(uv_write_t *req, int status);
+
+void _alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);
+
+godot_error Pipe::open(int fd, bool ipc = false) {
+  RETURN_IF_UV_ERR(uv_pipe_init(uv_default_loop(), &handle, ipc));
+
+  handle.data = this;
+
+  RETURN_IF_UV_ERR(uv_pipe_open(&handle, fd));
+  RETURN_IF_UV_ERR(uv_stream_set_blocking((uv_stream_t *)&handle, false));
+  RETURN_IF_UV_ERR(
+      uv_read_start((uv_stream_t *)&handle, _alloc_buffer, _read_cb));
+
+  return GODOT_OK;
+}
+
+godot_error Pipe::write(String p_data) {
+  char *s = p_data.alloc_c_string();
+  size_t len = strlen(s);
+
+  uv_buf_t bufs[] = {{.base = s, .len = len}};
+
+  uv_write_t req;
+
+  req.data = s;
+
+  uv_write(&req, (uv_stream_t *)&handle, bufs, 1, _write_cb);
+
+  uv_run(uv_default_loop(), UV_RUN_NOWAIT);
+
+  return GODOT_OK;
+}
+
+int Pipe::get_status() {
+  _poll_connection();
+  return status;
+}
+
+void Pipe::_poll_connection() { uv_run(uv_default_loop(), UV_RUN_NOWAIT); }
+
+void _read_cb(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf) {
+  Pipe *pipe = static_cast<Pipe *>(handle->data);
+  if (nread < 0) {
+    switch (nread) {
+    case UV_EOF:
+      // Normal after shell exits.
+      return;
+    case UV_EIO:
+      // Can happen when the process exits.
+      // As long as PTY has caught it, we should be fine.
+      return;
+    default:
+      UV_ERR_PRINT(nread);
+    }
+    return;
+  }
+
+  PoolByteArray data;
+  data.resize(nread);
+  memcpy(data.write().ptr(), buf->base, nread);
+
+  pipe->emit_signal("data_received", data);
+}
+
+void _write_cb(uv_write_t *req, int status) {}
+
+void _alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
+  buf->base = (char *)malloc(suggested_size);
+  buf->len = suggested_size;
+}

addons/godot_xterm/native/src/pipe.h

@@ -0,0 +1,64 @@
+// Copyright (c) 2021, Leroy Hopson (MIT License).
+
+#ifndef GODOT_XTERM_PIPE_H
+#define GODOT_XTERM_PIPE_H
+
+#include <Array.hpp>
+#include <FuncRef.hpp>
+#include <Godot.hpp>
+#include <Reference.hpp>
+#include <StreamPeer.hpp>
+#include <StreamPeerBuffer.hpp>
+#include <StreamPeerGDNative.hpp>
+#include <uv.h>
+
+namespace godot {
+
+class Pipe : public Reference {
+  GODOT_CLASS(Pipe, Reference)
+
+public:
+  uv_pipe_t handle;
+
+  static void _register_methods();
+
+  enum Status {
+    NONE,
+    CONNECTING,
+    CONNECTED,
+    ERROR,
+  };
+
+  int STATUS_NONE = Status::NONE;
+  int STATUS_CONNECTING = Status::CONNECTING;
+  int STATUS_CONNECTED = Status::CONNECTING;
+  int STATUS_ERROR = Status::ERROR;
+
+  Pipe();
+  ~Pipe();
+
+  void _init();
+
+  godot_error open(int fd, bool ipc);
+  int get_status();
+
+  godot_error write(String p_data);
+
+  void pause();
+  void resume();
+
+protected:
+  const godot_net_stream_peer *interface;
+
+public:
+  Status status;
+
+private:
+  void _poll_connection();
+
+  static godot_error _translate_error(int err);
+};
+
+} // namespace godot
+
+#endif // GODOT_XTERM_PIPE_H

addons/godot_xterm/native/src/pseudoterminal.cpp

@@ -1,155 +0,0 @@
-#include "pseudoterminal.h"
-#include <libgen.h>
-#include <sys/wait.h>
-#include <termios.h>
-#include <unistd.h>
-
-// Platform specific includes.
-#if defined(__linux__)
-#include <pty.h>
-#endif
-#if defined(__APPLE__)
-#include <sys/ioctl.h>
-#include <util.h>
-#endif
-
-using namespace godot;
-
-void Pseudoterminal::_register_methods() {
-
-  register_method("_init", &Pseudoterminal::_init);
-  register_method("_ready", &Pseudoterminal::_ready);
-
-  register_method("write", &Pseudoterminal::write);
-  register_method("resize", &Pseudoterminal::resize);
-
-  register_signal<Pseudoterminal>((char *)"data_sent", "data",
-                                  GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY);
-  register_signal<Pseudoterminal>((char *)"exited", "status",
-                                  GODOT_VARIANT_TYPE_INT);
-}
-
-Pseudoterminal::Pseudoterminal() {}
-
-Pseudoterminal::~Pseudoterminal() { pty_thread.join(); }
-
-void Pseudoterminal::_init() {
-  bytes_to_write = 0;
-  pty_thread = std::thread(&Pseudoterminal::process_pty, this);
-}
-
-void Pseudoterminal::process_pty() {
-  int fd;
-  char *name;
-  int status;
-
-  should_process_pty = true;
-
-  struct termios termios = {};
-  termios.c_iflag = IGNPAR | ICRNL;
-  termios.c_oflag = 0;
-  termios.c_cflag = B38400 | CRTSCTS | CS8 | CLOCAL | CREAD;
-  termios.c_lflag = ICANON;
-  termios.c_cc[VMIN] = 1;
-  termios.c_cc[VTIME] = 0;
-
-  pid_t pty_pid = forkpty(&fd, NULL, NULL, NULL);
-
-  if (pty_pid == -1) {
-    ERR_PRINT(
-        String("Error forking pty: {0}").format(Array::make(strerror(errno))));
-    should_process_pty = false;
-    return;
-  } else if (pty_pid == 0) {
-    /* Child */
-
-    char termenv[11] = {"TERM=xterm"};
-    putenv(termenv);
-
-    char colortermenv[20] = {"COLORTERM=truecolor"};
-    putenv(colortermenv);
-
-    char *shell = getenv("SHELL");
-    char *argv[] = {basename(shell), NULL};
-    execvp(shell, argv);
-  } else {
-    Vector2 zero = Vector2(0, 0);
-
-    /* Parent */
-    while (1) {
-      {
-        std::lock_guard<std::mutex> guard(size_mutex);
-        if (size != zero) {
-          struct winsize ws;
-          memset(&ws, 0, sizeof(ws));
-          ws.ws_col = size.x;
-          ws.ws_row = size.y;
-
-          ioctl(fd, TIOCSWINSZ, &ws);
-        }
-      }
-
-      if (waitpid(pty_pid, &status, WNOHANG)) {
-        emit_signal("exited", status);
-        return;
-      }
-
-      int ready = -1;
-      fd_set read_fds;
-      fd_set write_fds;
-
-      FD_ZERO(&read_fds);
-      FD_SET(fd, &read_fds);
-      FD_SET(fd, &write_fds);
-
-      struct timeval timeout;
-      timeout.tv_sec = 10;
-      timeout.tv_usec = 0;
-
-      ready = select(fd + 1, &read_fds, &write_fds, NULL, &timeout);
-
-      if (ready > 0) {
-        if (FD_ISSET(fd, &write_fds)) {
-          std::lock_guard<std::mutex> guard(write_buffer_mutex);
-
-          if (bytes_to_write > 0) {
-            ::write(fd, write_buffer, bytes_to_write);
-            bytes_to_write = 0;
-          }
-        }
-
-        if (FD_ISSET(fd, &read_fds)) {
-          std::lock_guard<std::mutex> guard(read_buffer_mutex);
-
-          int ret;
-          int bytes_read = 0;
-
-          bytes_read = read(fd, read_buffer, MAX_READ_BUFFER_LENGTH);
-
-          // TODO: handle error (-1)
-          if (bytes_read <= 0)
-            continue;
-
-          PoolByteArray data = PoolByteArray();
-          data.resize(bytes_read);
-          memcpy(data.write().ptr(), read_buffer, bytes_read);
-
-          emit_signal("data_sent", PoolByteArray(data));
-        }
-      }
-    }
-  }
-}
-
-void Pseudoterminal::_ready() {}
-
-void Pseudoterminal::write(PoolByteArray data) {
-  std::lock_guard<std::mutex> guard(write_buffer_mutex);
-  bytes_to_write = data.size();
-  memcpy(write_buffer, data.read().ptr(), bytes_to_write);
-}
-
-void Pseudoterminal::resize(Vector2 new_size) {
-  std::lock_guard<std::mutex> guard(size_mutex);
-  size = new_size;
-}

addons/godot_xterm/native/src/pseudoterminal.h

@@ -1,49 +0,0 @@
-#ifndef PSEUDOTERMINAL_H
-#define PSEUDOTERMINAL_H
-
-#include <Godot.hpp>
-#include <Node.hpp>
-#include <mutex>
-#include <thread>
-
-namespace godot {
-
-class Pseudoterminal : public Node {
-  GODOT_CLASS(Pseudoterminal, Node)
-
-public:
-  static const int MAX_READ_BUFFER_LENGTH = 1024;
-  static const int MAX_WRITE_BUFFER_LENGTH = 1024;
-
-private:
-  std::thread pty_thread;
-  bool should_process_pty;
-
-  char write_buffer[MAX_WRITE_BUFFER_LENGTH];
-  int bytes_to_write;
-  std::mutex write_buffer_mutex;
-
-  char read_buffer[MAX_READ_BUFFER_LENGTH];
-  int bytes_to_read;
-  std::mutex read_buffer_mutex;
-
-  Vector2 size;
-  std::mutex size_mutex;
-
-  void process_pty();
-
-public:
-  static void _register_methods();
-
-  Pseudoterminal();
-  ~Pseudoterminal();
-
-  void _init();
-  void _ready();
-
-  void write(PoolByteArray data);
-  void resize(Vector2 size);
-};
-} // namespace godot
-
-#endif // PSEUDOTERMINAL_H

addons/godot_xterm/native/thirdparty/libuv

@@ -0,0 +1 @@
+Subproject commit 9ec6bb914febbd392b10bb9e774e25a7a15737c3

addons/godot_xterm/nodes/pseudoterminal/README.md

@@ -1,51 +0,0 @@
-# Pseudoterminal
-
-**Inherits:** [Node] < [Object]
-
-
-Can be used with the [Terminal] node to get an actual shell. Currently only tested/working on Linux and MacOS.
-
-## Methods
-
-| Returns | Signature                              |
-|---------|----------------------------------------|
-| void    | write **(** [PoolByteArray] data **)** |
-| void    | resize **(** [Vector2] size **)**      |
-
-## Signals
-
-- **data_sent** **(** [PoolByteArray] data **)**
-
-  Emitted when some data comes out of the pseudoterminal.
-  In a typical setup this signal would be connected to the [Terminal]'s `write()` method.
-
----
-
-- **exited** **(** [int] status **)**
-
-  Emitted when the pseudoterminal's process (typically a shell like `bash` or `sh`) has exited. `status` is the exit code.
-
-  For example, if you are using the terminal with a `bash` shell, then issuing the  `exit` command would cause this signal to be emitted.
-  ```bash
-  > exit
-  exit
-
-  ```
-
-## Method Descriptions
-
-- void **write** **(** [PoolByteArray] data **)**
-
-  Writes data to the pseudoterminal. In a typical setup this would be connected to the [Terminal]'s `data_sent()` signal.
-
-- void **resize** **(** [Vector2] size **)**
-
-  Used to notify the pseudoterminal about window size changes. In a typical setup it would be connected to the [Terminal]'s `size_changed()` signal.
-
-
-[Node]: https://docs.godotengine.org/en/stable/classes/class_node.html
-[int]: https://docs.godotengine.org/en/stable/classes/class_int.html
-[Object]: https://docs.godotengine.org/en/stable/classes/class_object.html
-[PoolByteArray]: https://docs.godotengine.org/en/stable/classes/class_poolbytearray.html
-[Terminal]: ../terminal/README.md
-[Vector2]: https://docs.godotengine.org/en/stable/classes/class_vector2.html

addons/godot_xterm/nodes/pty/libuv_utils.gd

@@ -0,0 +1,29 @@
+# Copyright (c) 2021, Leroy Hopson (MIT License)
+
+tool
+extends Object
+# Wrapper around libuv utility functions.
+# GDNative does not currently support registering static functions so we fake it.
+# Only the static functions of this class should be called.
+
+const LibuvUtils := preload("./libuv_utils.gdns")
+
+static func get_os_environ() -> Dictionary:
+	# While Godot has OS.get_environment(), I could see a way to get all environent
+	# variables, other than by OS.execute() which would require to much platform
+	# specific code. Easier to use libuv's utility function.
+	return LibuvUtils.new().get_os_environ()
+
+static func get_cwd() -> String:
+	# Use uv_cwd() rather than Directory.get_current_dir() because the latter
+	# defaults to res:// even if starting godot from a different directory.
+	return LibuvUtils.new().get_cwd()
+
+static func get_windows_build_number() -> int:
+	assert(OS.get_name() == "Windows", "This function is only supported on Windows.")
+	var release: String = LibuvUtils.new().get_os_release()
+	assert(false, "Not implemented.")
+	return 0
+
+static func new():
+	assert(false, "Abstract sealed (i.e. static) class should not be instantiated.")

addons/godot_xterm/nodes/pty/libuv_utils.gdns

@@ -4,5 +4,5 @@
 
 [resource]
 resource_name = "Terminal"
-class_name = "Pseudoterminal"
+class_name = "LibuvUtils"
 library = ExtResource( 1 )

addons/godot_xterm/nodes/pty/pipe.gdns

@@ -0,0 +1,8 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://addons/godot_xterm/native/godotxtermnative.gdnlib" type="GDNativeLibrary" id=1]
+
+[resource]
+resource_name = "Terminal"
+class_name = "Pipe"
+library = ExtResource( 1 )

addons/godot_xterm/nodes/pty/pty.gd

@@ -0,0 +1,261 @@
+# Derived from https://github.com/microsoft/node-pty/blob/main/src/terminal.ts
+# Copyright (c) 2012-2015, Christopher Jeffrey (MIT License)
+# Copyright (c) 2016, Daniel Imms (MIT License).
+# Copyright (c) 2018, Microsoft Corporation (MIT License).
+# Copyright (c) 2021, Leroy Hopson (MIT License).
+
+tool
+extends Node
+
+const LibuvUtils := preload("./libuv_utils.gd")
+const Pipe := preload("./pipe.gdns")
+const Terminal := preload("../terminal/terminal.gd")
+
+const DEFAULT_NAME := "xterm-256color"
+const DEFAULT_COLS := 80
+const DEFAULT_ROWS := 24
+const DEFAULT_ENV := {TERM = DEFAULT_NAME, COLORTERM = "truecolor"}
+
+## Default messages to indicate PAUSE/RESUME for automatic flow control.
+## To avoid conflicts with rebound XON/XOFF control codes (such as on-my-zsh),
+## the sequences can be customized in IPtyForkOptions.
+#const FLOW_CONTROL_PAUSE = char(0x13) # defaults to XOFF
+#const FLOW_CONTROL_RESUME = char(0x11) # defaults to XON
+
+enum Status { NONE, OPEN, EXITED, ERROR }
+const STATUS_NONE = Status.NONE
+const STATUS_OPEN = Status.OPEN
+const STATUS_EXITED = Status.EXITED
+const STATUS_ERROR = Status.ERROR
+
+# Any signal_number can be sent to the pty's process using the kill() function,
+# these are just the signals with numbers specified in the POSIX standard.
+enum Signal {
+	SIGHUP = 1,  # Hangup
+	SIGINT = 2,  # Terminal interrupt signal
+	SIGQUIT = 3,  # Terminal quit signal
+	SIGILL = 4,  # Illegal instruction
+	SIGTRAP = 5,  # Trace/breakpoint trap
+	SIGABRT = 6,  # Process abort signal
+	SIGFPE = 8,  # Erroneous arithmetic operation
+	SIGKILL = 9,  # Kill (cannot be caught or ignored)
+	SIGSEGV = 11,  # Invalid memory reference
+	SIGPIPE = 13,  # Write on a pipe with no one to read it
+	SIGALRM = 14,  # Alarm clock
+	SIGTERM = 15,  # Termination signal
+}
+
+signal data_received(data)
+signal exited(exit_code, signum)
+signal errored(message)
+
+export (NodePath) var terminal_path := NodePath() setget set_terminal_path
+
+var status := STATUS_NONE
+var error_string := ""
+var terminal: Terminal = null setget set_terminal
+
+## Name of the terminal to be set in environment ($TERM variable).
+#export (String) var term_name: String
+
+# The name of the process.
+var process: String
+
+# The process ID.
+var pid: int
+
+# The column size in characters.
+export (int) var cols: int = DEFAULT_COLS setget set_cols
+
+# The row size in characters.
+export (int) var rows: int = DEFAULT_ROWS setget set_rows
+
+# Working directory to be set for the child program.
+#export (String) var cwd := LibuvUtils.get_cwd()
+
+# Environment to be set for the child program.
+export (Dictionary) var env := DEFAULT_ENV
+
+# If true the environment variables in the env Dictionary will be merged with
+# the environment variables of the operating system (e.g. printenv), with the
+# former taking precedence in the case of conflicts.
+export (bool) var use_os_env := true
+
+# If true, pty will call fork() in in _ready().
+export (bool) var autostart := false
+
+# (EXPERIMENTAL)
+# If true, PTY node will create a blocking libuv loop in a new thread.
+# signals will be emitted using call_deferred.
+#export (bool) var use_threads := false
+
+## String encoding of the underlying pty.
+## If set, incoming data will be decoded to strings and outgoing strings to bytes applying this encoding.
+## If unset, incoming data will be delivered as raw bytes (PoolByteArray type).
+## By default 'utf8' is assumed, to unset it explicitly set it to `null`.
+#var encoding: String = "utf8"
+
+## (EXPERIMENTAL)
+## Whether to enable flow control handling (false by default). If enabled a message of `flow_control_pause`
+## will pause the socket and thus blocking the child program execution due to buffer back pressure.
+## A message of `flow_control_resume` will resume the socket into flow mode.
+## For performance reasons only a single message as a whole will match (no message part matching).
+## If flow control is enabled the `flow_control_pause` and `flow_control_resume` messages are not forwarded to
+## the underlying pseudoterminal.
+#var handle_flow_control: bool = false
+#
+## (EXPERIMENTAL)
+## The string that should pause the pty when `handle_flow_control` is true. Default is XOFF ("\u0013").
+#var flow_control_pause: String = FLOW_CONTROL_PAUSE
+#
+## (EXPERIMENTAL)
+## The string that should resume the pty when `handle_flow_control` is true. Default is XON ("\u0011").
+#var flow_control_resume: String = FLOW_CONTROL_RESUME
+
+#var _native_term # Platform appropriate instance of this class.
+var _pipe: Pipe
+
+
+func set_cols(value: int):
+	resize(value, rows)
+
+
+func set_rows(value: int):
+	resize(cols, value)
+
+
+func set_terminal_path(value := NodePath()):
+	terminal_path = value
+	set_terminal(get_node_or_null(terminal_path))
+
+
+func set_terminal(value: Terminal):
+	if terminal == value:
+		return
+
+	# Disconect the current terminal, if any.
+	if terminal:
+		disconnect("data_received", terminal, "write")
+		terminal.disconnect("data_sent", self, "write")
+		terminal.disconnect("size_changed", self, "resize")
+
+	terminal = value
+
+	if not terminal:
+		return
+
+	# Connect the new terminal.
+	# FIXME! resize(terminal.get_cols(), terminal.get_rows())
+	if not terminal.is_connected("size_changed", self, "resize"):
+		terminal.connect("size_changed", self, "resize")
+	if not terminal.is_connected("data_sent", self, "write"):
+		terminal.connect("data_sent", self, "write")
+	if not is_connected("data_received", terminal, "write"):
+		connect("data_received", terminal, "write")
+
+
+# Writes data to the socket.
+# data: The data to write.
+func write(data) -> void:
+	assert(data is String or data is PoolByteArray)
+
+	if data is PoolByteArray:
+		data = data.get_string_from_utf8()
+
+#	if handle_flow_control:
+#		# PAUSE/RESUME messages are not forwarded to the pty.
+#		if data == flow_control_pause:
+#			pause()
+#			return
+#		if data == flow_control_resume:
+#			resume()
+#			return
+#	# Everything else goes to the real pty.
+	_write(data)
+
+
+func _write(data: String) -> void:
+	if _pipe:
+		_pipe.write(data)
+
+
+# Resizes the dimensions of the pty.
+# cols: The number of columns.
+# rows: The number of rows.
+# Also accepts a single Vector2 argument where x is the the number of columns
+# and y is the number of rows.
+func resize(cols, rows = null) -> void:
+	assert(
+		(cols is Vector2 and rows == null) or (cols is int and rows is int),
+		"Usage: resize(size: Vector2) or resize(cols: int, rows: int)"
+	)
+
+	if cols is Vector2:
+		rows = cols.y  # Must get rows before reassigning cols!
+		cols = cols.x
+
+	if cols <= 0 or rows <= 0 or cols == NAN or rows == NAN or cols == INF or rows == INF:
+		push_error("Resizing must be done using positive cols and rows.")
+
+	_resize(cols, rows)
+
+
+func _resize(cols: int, rows: int) -> void:
+	assert(false, "Not implemented.")
+
+
+# Close, kill and destroy the pipe.
+func destroy() -> void:
+	pass
+
+
+# Kill the pty.
+# sigint: The signal to send. By default this is SIGHUP.
+# This is not supported on Windows.
+func kill(sigint: int = Signal.SIGHUP) -> void:
+	pass
+
+
+func fork(
+	p_file: String,
+	p_args = PoolStringArray(),
+	p_cwd: String = LibuvUtils.get_cwd(),
+	p_cols: int = DEFAULT_COLS,
+	p_rows: int = DEFAULT_ROWS
+):
+	push_error("Not implemented.")
+
+
+func open(cols: int = DEFAULT_COLS, rows: int = DEFAULT_ROWS) -> void:
+	pass
+
+
+func _parse_env(env: Dictionary = {}) -> PoolStringArray:
+	var keys := env.keys()
+	var pairs := PoolStringArray()
+
+	for key in keys:
+		var value = env[key]
+		var valid = key is String and value is String
+		assert(valid, "Env key/value pairs must be of type String/String.")
+
+		if not valid:
+			push_warning("Skipping invalid env key/value pair.")
+			continue
+
+		pairs.append("%s=%s" % [key, value])
+
+	return pairs
+
+
+func _process(_delta):
+	if _pipe:
+		_pipe.poll()
+
+
+func _notification(what: int):
+	match what:
+		NOTIFICATION_PARENTED:
+			var parent = get_parent()
+			if parent is Terminal:
+				set_terminal_path(get_path_to(parent))

addons/godot_xterm/nodes/pty/pty_icon.svg.import

@@ -2,15 +2,15 @@
 
 importer="texture"
 type="StreamTexture"
-path="res://.import/pseudoterminal_icon.svg-0b26aed87c28626d61aa92bd9e34d5a9.stex"
+path="res://.import/pty_icon.svg-e9e42570b4744b3370a02d174395c793.stex"
 metadata={
 "vram_texture": false
 }
 
 [deps]
 
-source_file="res://addons/godot_xterm/nodes/pseudoterminal/pseudoterminal_icon.svg"
+source_file="res://addons/godot_xterm/nodes/pty/pty_icon.svg"
-dest_files=[ "res://.import/pseudoterminal_icon.svg-0b26aed87c28626d61aa92bd9e34d5a9.stex" ]
+dest_files=[ "res://.import/pty_icon.svg-e9e42570b4744b3370a02d174395c793.stex" ]
 
 [params]
 

addons/godot_xterm/nodes/pty/unix/pty_unix.gd

@@ -0,0 +1,124 @@
+# Derived from https://github.com/microsoft/node-pty/blob/main/src/unixTerminal.ts
+# Copyright (c) 2012-2015, Christopher Jeffrey (MIT License).
+# Copyright (c) 2016, Daniel Imms (MIT License).
+# Copyright (c) 2018, Microsoft Corporation (MIT License).
+# Copyright (c) 2021, Leroy Hopson (MIT License).
+
+tool
+extends "../pty.gd"
+
+const PTYUnix = preload("./pty_unix.gdns")
+
+const FALLBACK_FILE = "sh"
+
+# Security warning: use this option with great caution, as opened file descriptors
+# with higher privileges might leak to the child program.
+var uid: int
+var gid: int
+
+var thread: Thread
+
+var _fd: int = -1
+var _exit_cb: FuncRef
+
+static func get_uid() -> int:
+	return -1  # Not implemented.
+
+static func get_gid() -> int:
+	return -1  # Not implemented.
+
+
+func _ready():
+	if autostart:
+		fork()
+
+
+func _resize(cols: int, rows: int) -> void:
+	if _fd < 0:
+		return
+
+	PTYUnix.new().resize(_fd, cols, rows)
+
+
+func _fork_thread(args):
+	var result = preload("./pty_unix.gdns").new().callv("fork", args)
+	print(result)
+	return result
+
+
+func fork(
+	file: String = OS.get_environment("SHELL"),
+	args: PoolStringArray = PoolStringArray(),
+	cwd = LibuvUtils.get_cwd(),
+	p_cols: int = DEFAULT_COLS,
+	p_rows: int = DEFAULT_ROWS,
+	uid: int = -1,
+	gid: int = -1,
+	utf8 = true
+):
+	# File.
+	if file.empty():
+		file = FALLBACK_FILE
+
+	# Environment variables.
+	# If we are using OS env vars, sanitize them to remove variables that might confuse our terminal.
+	var final_env := _sanitize_env(LibuvUtils.get_os_environ()) if use_os_env else {}
+	for key in env.keys():
+		final_env[key] = env[key]
+	var parsed_env: PoolStringArray = _parse_env(final_env)
+
+	# Exit callback.
+	_exit_cb = FuncRef.new()
+	_exit_cb.set_instance(self)
+	_exit_cb.function = "_on_exit"
+
+	# Actual fork.
+	var result = PTYUnix.new().fork(  # VERY IMPORTANT: The must be set null or 0, otherwise will get an ENOTSOCK error after connecting our pipe to the fd.
+		file, null, args, parsed_env, cwd, cols, rows, uid, gid, utf8, _exit_cb
+	)
+
+	if result[0] != OK:
+		push_error("Fork failed.")
+		status = STATUS_ERROR
+		return FAILED
+
+	_fd = result[1].fd
+	if _fd < 0:
+		push_error("File descriptor must be a non-negative integer value.")
+		status = STATUS_ERROR
+		return FAILED
+
+	_pipe = Pipe.new()
+	_pipe.open(_fd)
+
+	# Must connect to signal AFTER opening, otherwise we will get error ENOTSOCK.
+	_pipe.connect("data_received", self, "_on_pipe_data_received")
+
+	return OK
+
+
+func _on_pipe_data_received(data):
+	emit_signal("data_received", data)
+
+
+func _on_exit(exit_code: int, signum: int) -> void:
+	emit_signal("exited", exit_code, signum)
+
+
+func _sanitize_env(env: Dictionary) -> Dictionary:
+	# Make sure we didn't start our server from inside tmux.
+	env.erase("TMUX")
+	env.erase("TMUX_PANE")
+
+	# Make sure we didn't start our server from inside screen.
+	# http://web.mit.edu/gnu/doc/html/screen_20.html
+	env.erase("STY")
+	env.erase("WINDOW")
+
+	# Delete some variables that might confuse our terminal.
+	env.erase("WINDOWID")
+	env.erase("TERMCAP")
+	env.erase("COLUMNS")
+	env.erase("LINES")
+
+	return env

addons/godot_xterm/nodes/pty/unix/pty_unix.gdns

@@ -0,0 +1,7 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://addons/godot_xterm/native/godotxtermnative.gdnlib" type="GDNativeLibrary" id=1]
+
+[resource]
+class_name = "PTYUnix"
+library = ExtResource( 1 )

addons/godot_xterm/plugin.gd

@@ -1,6 +1,7 @@
 tool
 extends EditorPlugin
 
+var pty_supported := OS.get_name() in ["X11", "Server", "OSX"]
 var asciicast_import_plugin
 
 
@@ -15,9 +16,13 @@ func _enter_tree():
 	var terminal_icon = preload("res://addons/godot_xterm/nodes/terminal/terminal_icon.svg")
 	add_custom_type("Terminal", "Control", terminal_script, terminal_icon)
 
-	var pseudoterminal_script = preload("res://addons/godot_xterm/nodes/pseudoterminal/pseudoterminal.gdns")
+	if pty_supported:
-	var pseudoterminal_icon = preload("res://addons/godot_xterm/nodes/pseudoterminal/pseudoterminal_icon.svg")
+		var pty_icon = load("res://addons/godot_xterm/nodes/pty/pty_icon.svg")
-	add_custom_type("Pseudoterminal", "Node", pseudoterminal_script, pseudoterminal_icon)
+		var pty_script
+		match OS.get_name():
+			"X11", "Server", "OSX":
+				pty_script = load("res://addons/godot_xterm/nodes/pty/unix/pty_unix.gd")
+		add_custom_type("PTY", "Node", pty_script, pty_icon)
 
 
 func _exit_tree():
@@ -26,4 +31,6 @@ func _exit_tree():
 
 	remove_custom_type("Asciicast")
 	remove_custom_type("Terminal")
-	remove_custom_type("Psuedoterminal")
+
+	if pty_supported:
+		remove_custom_type("PTY")

examples/menu/menu.gd

@@ -150,11 +150,7 @@ func _on_Terminal_key_pressed(data: String, event: InputEventKey) -> void:
 						"Terminal not Supported on Windows"
 					)
 				var scene = item.scene.instance()
-				var pty = (
+				var pty = scene if OS.has_feature("JavaScript") else scene.get_node("PTY")
-					scene
-					if OS.has_feature("JavaScript")
-					else scene.get_node("Pseudoterminal")
-				)
 				get_tree().get_root().add_child(scene)
 				visible = false
 				scene.grab_focus()

examples/terminal/terminal.gd

@@ -0,0 +1,7 @@
+extends "res://addons/godot_xterm/nodes/terminal/terminal.gd"
+
+onready var pty = $PTY
+
+
+func _ready():
+	pty.fork(OS.get_environment("SHELL"))

examples/terminal/terminal.tscn

@@ -1,20 +1,21 @@
 [gd_scene load_steps=3 format=2]
 
-[ext_resource path="res://addons/godot_xterm/nodes/terminal/terminal.gd" type="Script" id=1]
+[ext_resource path="res://addons/godot_xterm/nodes/pty/unix/pty_unix.gd" type="Script" id=2]
-[ext_resource path="res://addons/godot_xterm/nodes/pseudoterminal/pseudoterminal.gdns" type="Script" id=2]
+[ext_resource path="res://examples/terminal/terminal.gd" type="Script" id=3]
 
 [node name="Terminal" type="Control"]
 anchor_right = 1.0
 anchor_bottom = 1.0
-focus_mode = 1
+focus_mode = 2
-script = ExtResource( 1 )
+script = ExtResource( 3 )
 __meta__ = {
 "_edit_use_anchors_": false
 }
 
-[node name="Pseudoterminal" type="Node" parent="."]
+[node name="PTY" type="Node" parent="."]
 script = ExtResource( 2 )
-
+terminal_path = NodePath("..")
-[connection signal="data_sent" from="." to="Pseudoterminal" method="write"]
+env = {
-[connection signal="size_changed" from="." to="Pseudoterminal" method="resize"]
+"COLORTERM": "truecolor",
-[connection signal="data_sent" from="Pseudoterminal" to="." method="write"]
+"TERM": "xterm-256color"
+}

misc/vscode/launch.json

@@ -0,0 +1,33 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "cpp - Build and debug active file",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "/run/current-system/sw/bin/godot",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                },
+                //{
+                //    "description": "Debug forked child process",
+                //    "text": "-gdb-set follow-fork-mode child",
+                //}
+            ],
+            "preLaunchTask": "build",
+            "miDebuggerPath": "gdb"
+        }
+    ]
+}

misc/vscode/settings.json

@@ -3,4 +3,21 @@
     "clang-format.executable": "/run/current-system/sw/bin/clang-format",
     "gut-extension.additionalOptions": "-d --no-window",
     "nixEnvSelector.nixShellConfig": "NOT_MODIFIED_ENV",
+    "files.associations": {
+        "array": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "numeric": "cpp",
+        "sstream": "cpp",
+        "streambuf": "cpp",
+        "utility": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "system_error": "cpp",
+        "functional": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "*.inc": "cpp"
+    }
 }

test/integration/unix/pty_unix.test.gd

@@ -0,0 +1,117 @@
+extends "res://addons/gut/test.gd"
+# WARNING: These test can only be run on the "Unix" platforms (X11, Server, and OSX).
+# Some of the tests also rely on listing the files in /dev/pts. If you open or close
+# terminals while these tests are running, it may cause inaccurate results.
+
+const PTYUnixNative := preload("res://addons/godot_xterm/nodes/pty/unix/pty_unix.gdns")
+const PTYUnix := preload("res://addons/godot_xterm/nodes/pty/unix/pty_unix.gd")
+
+
+func before_all():
+	assert(
+		OS.get_name() in ["X11", "Server", "OSX"], "Unix only tests cannot be run on this platform."
+	)
+
+
+class TestFork:
+	extends "res://addons/gut/test.gd"
+
+	const PTYUnix := preload("res://addons/godot_xterm/nodes/pty/unix/pty_unix.gd")
+
+	var sh_path: String
+
+	func before_all():
+		var output = []
+		var exit_code = OS.execute("command", PoolStringArray(["-v", "sh"]), true, output)
+		assert(exit_code == 0, "sh is required for these tests.")
+		sh_path = output[0].strip_edges()
+
+	func test_fork_creates_new_pts():
+		var num_pts = Helper._get_pts().size()
+
+		var pty = PTYUnix.new()
+		add_child_autofree(pty)
+		var err = pty.fork(sh_path)
+		assert_eq(err, OK)
+
+		var new_num_pts = Helper._get_pts().size()
+		assert_eq(new_num_pts, num_pts + 1)
+
+
+class TestOpen:
+	extends "res://addons/gut/test.gd"
+
+	func test_open_creates_new_pts():
+		var num_pts = Helper._get_pts().size()
+
+		var result = PTYUnixNative.new().open(0, 0)
+		assert_eq(result[0], OK)
+
+		var new_num_pts = Helper._get_pts().size()
+		assert_eq(new_num_pts, num_pts + 1)
+
+	func test_pty_has_correct_name():
+		var original_pts = Helper._get_pts()
+
+		var result = PTYUnixNative.new().open(0, 0)
+		assert_eq(result[0], OK)
+
+		var new_pts = Helper._get_pts()
+		for pt in original_pts:
+			new_pts.erase(pt)
+		assert_true(result[1].pty in new_pts)
+
+	func test_pty_has_correct_win_size():
+		var cols = 7684
+		var rows = 9314
+
+		var result = PTYUnixNative.new().open(cols, rows)
+		assert_eq(result[0], OK)
+
+		var winsize = Helper._get_winsize(result[1].master)
+		assert_eq(winsize.cols, cols)
+		assert_eq(winsize.rows, rows)
+
+
+class Helper:
+	static func _get_pts() -> Array:
+		var dir := Directory.new()
+
+		if dir.open("/dev/pts") != OK or dir.list_dir_begin(true, true) != OK:
+			assert(false, "Could not open /dev/pts.")
+
+		var pts := []
+		var file_name := dir.get_next()
+
+		while file_name != "":
+			if file_name.is_valid_integer():
+				pts.append("/dev/pts/%s" % file_name)
+			file_name = dir.get_next()
+
+		return pts
+
+	static func _get_winsize(fd: int) -> Dictionary:
+		var output = []
+
+		assert(
+			OS.execute("command", ["-v", "python"], true, output) == 0,
+			"Python must be installed to run this test."
+		)
+		var python_path = output[0].strip_edges()
+
+		var exit_code = OS.execute(
+			python_path,
+			[
+				"-c",
+				(
+					"import struct, fcntl, termios; print(struct.unpack('hh', fcntl.ioctl(%d, termios.TIOCGWINSZ, '1234')))"
+					% fd
+				)
+			],
+			true,
+			output
+		)
+		assert(exit_code == 0, "Failed to run python command for this test.")
+
+		var size = str2var("Vector2" + output[0].strip_edges())
+		return {rows = int(size.x), cols = int(size.y)}

test/integration/uv_utils/uv_utils.test.gd

@@ -0,0 +1,30 @@
+extends "res://addons/gut/test.gd"
+
+const LibuvUtils := preload("res://addons/godot_xterm/nodes/pty/libuv_utils.gd")
+
+
+class TestGetOSEnviron:
+	extends "res://addons/gut/test.gd"
+
+	const EMPTY_VAR = "GODOT_XTERM_TEST_EMPTY_ENV_VAR"
+	const TEST_VAR = "GODOT_XTERM_TEST_ENV_VAR"
+	const TEST_VAL = "TEST123"
+
+	var env: Dictionary
+
+	func before_each():
+		assert(OS.set_environment(EMPTY_VAR, ""))
+		assert(OS.set_environment(TEST_VAR, TEST_VAL))
+		env = LibuvUtils.get_os_environ()
+
+	func test_has_empty_var():
+		assert_has(env, EMPTY_VAR)
+
+	func test_empty_var_has_empty_val():
+		assert_eq(env[EMPTY_VAR], "")
+
+	func test_has_test_var():
+		assert_has(env, TEST_VAR)
+
+	func test_test_var_has_correct_val():
+		assert_eq(env[TEST_VAR], TEST_VAL)