bare-tty 5.1.2 → 5.2.1

package/binding.c

@@ -9,7 +9,6 @@ typedef struct {
 
   struct {
     uv_write_t write;
-    uv_shutdown_t shutdown;
   } requests;
 
   uv_buf_t read;
@@ -192,13 +191,13 @@ static js_value_t *
 bare_tty_init(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 6;
-  js_value_t *argv[6];
+  size_t argc = 7;
+  js_value_t *argv[7];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 6);
+  assert(argc == 7);
 
   uv_loop_t *loop;
   err = js_get_env_loop(env, &loop);
@@ -217,22 +216,33 @@ bare_tty_init(js_env_t *env, js_callback_info_t *info) {
   err = uv_tty_init(loop, &tty->handle, fd, 1);
 
   if (err < 0) {
-    js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
     return NULL;
   }
 
-  err = uv_stream_set_blocking((uv_stream_t *) &tty->handle, true);
+  bool blocking;
+  err = js_get_value_bool(env, argv[6], &blocking);
+  assert(err == 0);
 
-  // Not all platforms support blocking TTY handles.
-  (void) err;
+  if (blocking) {
+    err = uv_stream_set_blocking((uv_stream_t *) &tty->handle, true);
+
+    // Not all platforms support blocking TTY handles.
+    (void) err;
+  }
 
   tty->env = env;
   tty->closing = false;
   tty->exiting = false;
 
-  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &tty->read.base, (size_t *) &tty->read.len, NULL, NULL);
+  size_t read_len;
+  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &tty->read.base, &read_len, NULL, NULL);
   assert(err == 0);
 
+  tty->read.len = read_len;
+
   err = js_create_reference(env, argv[2], 1, &tty->ctx);
   assert(err == 0);
 
@@ -277,18 +287,31 @@ bare_tty_writev(js_env_t *env, js_callback_info_t *info) {
 
   js_value_t **elements = malloc(sizeof(js_value_t *) * bufs_len);
 
+  if ((bufs == NULL || elements == NULL) && bufs_len > 0) {
+    free(bufs);
+    free(elements);
+
+    err = js_throw_error(env, uv_err_name(UV_ENOMEM), uv_strerror(UV_ENOMEM));
+    assert(err == 0);
+
+    return NULL;
+  }
+
   uint32_t fetched;
   err = js_get_array_elements(env, arr, elements, bufs_len, 0, &fetched);
   assert(err == 0);
   assert(fetched == bufs_len);
 
-
   for (uint32_t i = 0; i < bufs_len; i++) {
     js_value_t *item = elements[i];
 
     uv_buf_t *buf = &bufs[i];
-    err = js_get_typedarray_info(env, item, NULL, (void **) &buf->base, (size_t *) &buf->len, NULL, NULL);
+
+    size_t buf_len;
+    err = js_get_typedarray_info(env, item, NULL, (void **) &buf->base, &buf_len, NULL, NULL);
     assert(err == 0);
+
+    buf->len = buf_len;
   }
 
   free(elements);
@@ -302,7 +325,9 @@ bare_tty_writev(js_env_t *env, js_callback_info_t *info) {
   free(bufs);
 
   if (err < 0) {
-    js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
     return NULL;
   }
 
@@ -328,7 +353,9 @@ bare_tty_resume(js_env_t *env, js_callback_info_t *info) {
   err = uv_read_start((uv_stream_t *) &tty->handle, bare_tty__on_alloc, bare_tty__on_read);
 
   if (err < 0) {
-    js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
     return NULL;
   }
 
@@ -354,7 +381,9 @@ bare_tty_pause(js_env_t *env, js_callback_info_t *info) {
   err = uv_read_stop((uv_stream_t *) &tty->handle);
 
   if (err < 0) {
-    js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
     return NULL;
   }
 
@@ -377,6 +406,8 @@ bare_tty_close(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
+  if (tty->closing) return NULL;
+
   err = uv_tty_set_mode(&tty->handle, UV_TTY_MODE_NORMAL);
 
   // Resetting the mode won't always work, in particular on Windows when we
@@ -413,7 +444,9 @@ bare_tty_set_mode(js_env_t *env, js_callback_info_t *info) {
   err = uv_tty_set_mode(&tty->handle, mode);
 
   if (err < 0) {
-    js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
     return NULL;
   }
 
@@ -440,7 +473,9 @@ bare_tty_get_window_size(js_env_t *env, js_callback_info_t *info) {
   err = uv_tty_get_winsize(&tty->handle, &width, &height);
 
   if (err < 0) {
-    js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
     return NULL;
   }
 

package/index.d.ts

@@ -1,5 +1,10 @@
 import { Readable, ReadableOptions, Writable, WritableEvents, WritableOptions } from 'bare-stream'
 import constants from './lib/constants'
+import TTYError from './lib/errors'
+
+interface ReadStreamOptions extends ReadableOptions {
+  readBufferSize?: number
+}
 
 interface ReadStream extends Readable {
   readonly fd: number
@@ -10,7 +15,7 @@ interface ReadStream extends Readable {
 }
 
 declare class ReadStream extends Readable {
-  constructor(fd: number, opts?: ReadableOptions)
+  constructor(fd: number, opts?: ReadStreamOptions)
 }
 
 interface WriteStreamEvents extends WritableEvents {
@@ -32,4 +37,13 @@ declare class WriteStream<M extends WriteStreamEvents = WriteStreamEvents> exten
 
 declare function isTTY(fd: number): boolean
 
-export { ReadStream, WriteStream, isTTY, isTTY as isatty, constants }
+export {
+  type ReadStreamOptions,
+  ReadStream,
+  WriteStream,
+  isTTY,
+  isTTY as isatty,
+  constants,
+  type TTYError,
+  TTYError as errors
+}

package/index.js

@@ -2,24 +2,28 @@ const { Readable, Writable } = require('bare-stream')
 const Signal = require('bare-signals')
 const binding = require('./binding')
 const constants = require('./lib/constants')
+const errors = require('./lib/errors')
 
 const defaultReadBufferSize = 65536
 const empty = Buffer.alloc(0)
+const modes = new Set([constants.mode.NORMAL, constants.mode.RAW, constants.mode.IO])
 
 exports.ReadStream = class TTYReadStream extends Readable {
   constructor(fd, opts = {}) {
-    super()
+    super(opts)
 
-    const { readBufferSize = defaultReadBufferSize, allowHalfOpen = true } = opts
+    const { readBufferSize = defaultReadBufferSize } = opts
+
+    validateFd(fd)
+    validateInteger(readBufferSize, 'Read buffer size', 1, 0x7fffffff)
 
     this._fd = fd
     this._state = 0
-    this._allowHalfOpen = allowHalfOpen
     this._buffer = Buffer.alloc(readBufferSize)
 
     this._pendingDestroy = null
 
-    this._handle = binding.init(fd, this._buffer, this, noop, this._onread, this._onclose)
+    this._handle = binding.init(fd, this._buffer, this, noop, this._onread, this._onclose, false)
   }
 
   get fd() {
@@ -31,7 +35,12 @@ exports.ReadStream = class TTYReadStream extends Readable {
   }
 
   setMode(mode) {
+    validateMode(mode)
+
+    this._alive()
+
     binding.setMode(this._handle, mode)
+
     return this
   }
 
@@ -39,6 +48,12 @@ exports.ReadStream = class TTYReadStream extends Readable {
     return this.setMode(enabled ? constants.mode.RAW : constants.mode.NORMAL)
   }
 
+  _alive() {
+    if (this._state & constants.state.CLOSING) {
+      throw errors.STREAM_IS_CLOSED('Stream is closed')
+    }
+  }
+
   _read() {
     if ((this._state & constants.state.READING) === 0) {
       this._state |= constants.state.READING
@@ -48,18 +63,21 @@ exports.ReadStream = class TTYReadStream extends Readable {
   }
 
   _predestroy() {
-    if (this._state & constants.state.CLOSING) return
-    this._state |= constants.state.CLOSING
-
-    binding.close(this._handle)
+    this._close()
   }
 
   _destroy(err, cb) {
-    if (this._state & constants.state.CLOSING) return cb(err)
-    this._state |= constants.state.CLOSING
+    if (this._state & constants.state.CLOSED) return cb(err)
 
     this._pendingDestroy = cb
 
+    this._close()
+  }
+
+  _close() {
+    if (this._state & constants.state.CLOSING) return
+    this._state |= constants.state.CLOSING
+
     binding.close(this._handle)
   }
 
@@ -78,11 +96,13 @@ exports.ReadStream = class TTYReadStream extends Readable {
 
     if (read === 0) {
       this.push(null)
-      if (this._allowHalfOpen === false) this.end()
       return
     }
 
-    const copy = Buffer.allocUnsafe(read)
+    // Unpooled, as a read too small to be given a buffer of its own would
+    // otherwise pin the whole pool it came from for as long as its consumer
+    // holds on to it.
+    const copy = Buffer.allocUnsafeSlow(read)
     copy.set(this._buffer.subarray(0, read))
 
     if (this.push(copy) === false && this.destroying === false) {
@@ -93,7 +113,7 @@ exports.ReadStream = class TTYReadStream extends Readable {
   }
 
   _onclose() {
-    this._handle = null
+    this._state |= constants.state.CLOSED
 
     this._continueDestroy()
   }
@@ -101,7 +121,9 @@ exports.ReadStream = class TTYReadStream extends Readable {
 
 exports.WriteStream = class TTYWriteStream extends Writable {
   constructor(fd, opts = {}) {
-    super()
+    super(opts)
+
+    validateFd(fd)
 
     this._fd = fd
     this._state = 0
@@ -111,9 +133,15 @@ exports.WriteStream = class TTYWriteStream extends Writable {
     this._pendingWriteBatch = null
     this._pendingDestroy = null
 
-    this._handle = binding.init(fd, empty, this, this._onwrite, noop, this._onclose)
+    this._handle = binding.init(fd, empty, this, this._onwrite, noop, this._onclose, true)
 
-    this._size = this.getWindowSize()
+    try {
+      this._refreshSize()
+    } catch (err) {
+      this._close()
+
+      throw err
+    }
 
     if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.start()
 
@@ -137,7 +165,25 @@ exports.WriteStream = class TTYWriteStream extends Writable {
   }
 
   getWindowSize() {
-    return binding.getWindowSize(this._handle)
+    this._alive()
+
+    return [this._size[0], this._size[1]]
+  }
+
+  _refreshSize() {
+    const size = binding.getWindowSize(this._handle)
+
+    const changed = this._size === null || size[0] !== this._size[0] || size[1] !== this._size[1]
+
+    this._size = size
+
+    return changed
+  }
+
+  _alive() {
+    if (this._state & constants.state.CLOSING) {
+      throw errors.STREAM_IS_CLOSED('Stream is closed')
+    }
   }
 
   _writev(batch, cb) {
@@ -145,6 +191,8 @@ exports.WriteStream = class TTYWriteStream extends Writable {
     this._pendingWriteBatch = batch
 
     try {
+      coerceBatch(batch)
+
       binding.writev(
         this._handle,
         batch.map(({ chunk }) => chunk)
@@ -155,22 +203,21 @@ exports.WriteStream = class TTYWriteStream extends Writable {
   }
 
   _predestroy() {
-    if (this._state & constants.state.CLOSING) return
-    this._state |= constants.state.CLOSING
+    this._close()
+  }
 
-    binding.close(this._handle)
+  _destroy(err, cb) {
+    if (this._state & constants.state.CLOSED) return cb(err)
 
-    TTYWriteStream._streams.delete(this)
+    this._pendingDestroy = cb
 
-    if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.stop()
+    this._close()
   }
 
-  _destroy(err, cb) {
-    if (this._state & constants.state.CLOSING) return cb(err)
+  _close() {
+    if (this._state & constants.state.CLOSING) return
     this._state |= constants.state.CLOSING
 
-    this._pendingDestroy = cb
-
     binding.close(this._handle)
 
     TTYWriteStream._streams.delete(this)
@@ -198,15 +245,22 @@ exports.WriteStream = class TTYWriteStream extends Writable {
   }
 
   _onclose() {
-    this._handle = null
+    this._state |= constants.state.CLOSED
 
     this._continueDestroy()
   }
 
   _onresize() {
-    this._size = this.getWindowSize()
+    let changed
 
-    this.emit('resize')
+    try {
+      changed = this._refreshSize()
+    } catch (err) {
+      this.emit('error', err)
+      return
+    }
+
+    if (changed) this.emit('resize')
   }
 
   static _streams = new Set()
@@ -216,7 +270,11 @@ exports.WriteStream = class TTYWriteStream extends Writable {
 
 exports.constants = constants
 
-exports.isTTY = binding.isTTY
+exports.errors = errors
+
+exports.isTTY = function isTTY(fd) {
+  return isValidFd(fd) && binding.isTTY(fd)
+}
 
 exports.isatty = exports.isTTY // For Node.js compatibility
 
@@ -228,4 +286,54 @@ exports.WriteStream._resize
   })
   .unref()
 
+function isValidFd(fd) {
+  return typeof fd === 'number' && Number.isInteger(fd) && fd >= 0 && fd <= 0x7fffffff
+}
+
+function validateFd(fd) {
+  if (typeof fd !== 'number') {
+    throw errors.INVALID_FD(`File descriptor must be a number, got ${typeof fd}`)
+  }
+
+  if (!isValidFd(fd)) {
+    throw errors.INVALID_FD(
+      `File descriptor must be an integer between 0 and ${0x7fffffff}, got ${fd}`
+    )
+  }
+}
+
+function validateMode(mode) {
+  if (typeof mode !== 'number') {
+    throw errors.INVALID_ARGUMENT(`Mode must be a number, got ${typeof mode}`)
+  }
+
+  if (!modes.has(mode)) {
+    throw errors.INVALID_ARGUMENT(`Mode must be one of ${[...modes].join(', ')}, got ${mode}`)
+  }
+}
+
+function validateInteger(value, name, min, max) {
+  if (typeof value !== 'number') {
+    throw errors.INVALID_ARGUMENT(`${name} must be a number, got ${typeof value}`)
+  }
+
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw errors.INVALID_ARGUMENT(
+      `${name} must be an integer between ${min} and ${max}, got ${value}`
+    )
+  }
+}
+
+function coerceBatch(batch) {
+  for (let i = 0; i < batch.length; i++) {
+    const chunk = batch[i].chunk
+
+    if (ArrayBuffer.isView(chunk) === false) {
+      throw errors.INVALID_ARGUMENT(`Chunk must be a string or a view, got ${typeof chunk}`)
+    }
+
+    batch[i].chunk = Buffer.coerce(chunk)
+  }
+}
+
 function noop() {}

package/lib/constants.d.ts

@@ -1,6 +1,6 @@
 declare const constants: {
   mode: { NORMAL: number; RAW: number; IO: number }
-  state: { READING: number; CLOSING: number }
+  state: { READING: number; CLOSING: number; CLOSED: number }
 }
 
 export = constants

package/lib/constants.js

@@ -9,7 +9,8 @@ module.exports = exports = {
 
   state: {
     READING: 0x1,
-    CLOSING: 0x2
+    CLOSING: 0x2,
+    CLOSED: 0x4
   }
 }
 

package/lib/errors.d.ts

@@ -0,0 +1,5 @@
+declare class TTYError extends Error {
+  readonly code: string
+}
+
+export = TTYError

package/lib/errors.js

@@ -0,0 +1,26 @@
+module.exports = class TTYError extends Error {
+  constructor(msg, fn = TTYError, code = fn.name) {
+    super(`${code}: ${msg}`)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name() {
+    return 'TTYError'
+  }
+
+  static STREAM_IS_CLOSED(msg) {
+    return new TTYError(msg, TTYError.STREAM_IS_CLOSED)
+  }
+
+  static INVALID_FD(msg) {
+    return new TTYError(msg, TTYError.INVALID_FD)
+  }
+
+  static INVALID_ARGUMENT(msg) {
+    return new TTYError(msg, TTYError.INVALID_ARGUMENT)
+  }
+}

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "bare-tty",
-  "version": "5.1.2",
+  "version": "5.2.1",
   "description": "Native TTY streams for JavaScript",
   "exports": {
+    "./package": "./package.json",
     ".": {
       "types": "./index.d.ts",
       "default": "./index.js"
     },
-    "./package": "./package.json",
-    "./constants": "./lib/constants.js"
+    "./constants": {
+      "types": "./lib/constants.d.ts",
+      "default": "./lib/constants.js"
+    },
+    "./errors": {
+      "types": "./lib/errors.d.ts",
+      "default": "./lib/errors.js"
+    }
   },
   "files": [
     "index.js",
@@ -44,6 +51,7 @@
     "bare-stream": "^2.0.0"
   },
   "devDependencies": {
+    "bare-subprocess": "^6.0.0",
     "brittle": "^3.2.1",
     "cmake-bare": "^1.1.6",
     "lunte": "^1.8.0",