@jingyi0605/codingns 0.8.0 → 0.8.5

package/vendor/node-pty-fork/src/win/winpty.cc

@@ -0,0 +1,322 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ *
+ * pty.cc:
+ *   This file is responsible for starting processes
+ *   with pseudo-terminal file descriptors.
+ */
+
+#include <iostream>
+#include <nan.h>
+#include <Shlwapi.h> // PathCombine, PathIsRelative
+#include <sstream>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <winpty.h>
+
+#include "path_util.h"
+
+/**
+* Misc
+*/
+extern "C" void init(v8::Local<v8::Object>);
+
+#define WINPTY_DBG_VARIABLE TEXT("WINPTYDBG")
+
+/**
+* winpty
+*/
+static std::vector<winpty_t *> ptyHandles;
+static volatile LONG ptyCounter;
+
+/**
+* Helpers
+*/
+
+static winpty_t *get_pipe_handle(int handle) {
+  for (size_t i = 0; i < ptyHandles.size(); ++i) {
+    winpty_t *ptyHandle = ptyHandles[i];
+    int current = (int)winpty_agent_process(ptyHandle);
+    if (current == handle) {
+      return ptyHandle;
+    }
+  }
+  return nullptr;
+}
+
+static bool remove_pipe_handle(int handle) {
+  for (size_t i = 0; i < ptyHandles.size(); ++i) {
+    winpty_t *ptyHandle = ptyHandles[i];
+    if ((int)winpty_agent_process(ptyHandle) == handle) {
+      winpty_free(ptyHandle);
+      ptyHandles.erase(ptyHandles.begin() + i);
+      ptyHandle = nullptr;
+      return true;
+    }
+  }
+  return false;
+}
+
+void throw_winpty_error(const char *generalMsg, winpty_error_ptr_t error_ptr) {
+  std::stringstream why;
+  std::wstring msg(winpty_error_msg(error_ptr));
+  std::string msg_(msg.begin(), msg.end());
+  why << generalMsg << ": " << msg_;
+  Nan::ThrowError(why.str().c_str());
+  winpty_error_free(error_ptr);
+}
+
+static NAN_METHOD(PtyGetExitCode) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.getExitCode(pidHandle)");
+    return;
+  }
+
+  DWORD exitCode = 0;
+  GetExitCodeProcess((HANDLE)info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust(), &exitCode);
+
+  info.GetReturnValue().Set(Nan::New<v8::Number>(exitCode));
+}
+
+static NAN_METHOD(PtyGetProcessList) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.getProcessList(pid)");
+    return;
+  }
+
+  int pid = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  winpty_t *pc = get_pipe_handle(pid);
+  if (pc == nullptr) {
+    info.GetReturnValue().Set(Nan::New<v8::Array>(0));
+    return;
+  }
+  int processList[64];
+  const int processCount = 64;
+  int actualCount = winpty_get_console_process_list(pc, processList, processCount, nullptr);
+
+  v8::Local<v8::Array> result = Nan::New<v8::Array>(actualCount);
+  for (uint32_t i = 0; i < actualCount; i++) {
+    Nan::Set(result, i, Nan::New<v8::Number>(processList[i]));
+  }
+  info.GetReturnValue().Set(result);
+}
+
+static NAN_METHOD(PtyStartProcess) {
+  Nan::HandleScope scope;
+
+  std::stringstream why;
+  const wchar_t *filename = nullptr;
+  const wchar_t *cmdline = nullptr;
+  const wchar_t *cwd = nullptr;
+  std::wstring env;
+  int cols = 0;
+  int rows = 0;
+  bool debug = false;
+  winpty_error_ptr_t error_ptr = nullptr;
+  winpty_config_t* winpty_config = nullptr;
+  winpty_t *pc = nullptr;
+  winpty_spawn_config_t* config = nullptr;
+  HANDLE handle = nullptr;
+  BOOL spawnSuccess = FALSE;
+  v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
+
+  if (info.Length() != 7 ||
+      !info[0]->IsString() ||
+      !info[1]->IsString() ||
+      !info[2]->IsArray() ||
+      !info[3]->IsString() ||
+      !info[4]->IsNumber() ||
+      !info[5]->IsNumber() ||
+      !info[6]->IsBoolean()) {
+    Nan::ThrowError("Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
+    return;
+  }
+
+  filename = path_util::to_wstring(Nan::Utf8String(info[0]));
+  cmdline = path_util::to_wstring(Nan::Utf8String(info[1]));
+  cwd = path_util::to_wstring(Nan::Utf8String(info[3]));
+
+  // create environment block
+  const v8::Local<v8::Array> envValues = v8::Local<v8::Array>::Cast(info[2]);
+  if (!envValues.IsEmpty()) {
+
+    std::wstringstream envBlock;
+
+    for(uint32_t i = 0; i < envValues->Length(); i++) {
+      std::wstring envValue(path_util::to_wstring(Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
+      envBlock << envValue << L'\0';
+    }
+
+    env = envBlock.str();
+  }
+
+  // use environment 'Path' variable to determine location of
+  // the relative path that we have recieved (e.g cmd.exe)
+  std::wstring shellpath;
+  if (::PathIsRelativeW(filename)) {
+    shellpath = path_util::get_shell_path(filename);
+  } else {
+    shellpath = filename;
+  }
+
+  std::string shellpath_(shellpath.begin(), shellpath.end());
+
+  if (shellpath.empty() || !path_util::file_exists(shellpath)) {
+    why << "File not found: " << shellpath_;
+    Nan::ThrowError(why.str().c_str());
+    goto cleanup;
+  }
+
+  cols = info[4]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  rows = info[5]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  debug = Nan::To<bool>(info[6]).FromJust();
+
+  // Enable/disable debugging
+  SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
+
+  // Create winpty config
+  winpty_config = winpty_config_new(0, &error_ptr);
+  if (winpty_config == nullptr) {
+    throw_winpty_error("Error creating WinPTY config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set pty size on config
+  winpty_config_set_initial_size(winpty_config, cols, rows);
+
+  // Start the pty agent
+  pc = winpty_open(winpty_config, &error_ptr);
+  winpty_config_free(winpty_config);
+  if (pc == nullptr) {
+    throw_winpty_error("Error launching WinPTY agent", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Save pty struct for later use
+  ptyHandles.insert(ptyHandles.end(), pc);
+
+  // Create winpty spawn config
+  config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd, env.c_str(), &error_ptr);
+  if (config == nullptr) {
+    throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Spawn the new process
+  spawnSuccess = winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
+  winpty_spawn_config_free(config);
+  if (!spawnSuccess) {
+    throw_winpty_error("Unable to start terminal process", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set return values
+  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>((int)GetProcessId(handle)));
+  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(), Nan::New<v8::Number>((int)handle));
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>((int)winpty_agent_process(pc)));
+  Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  {
+    LPCWSTR coninPipeName = winpty_conin_name(pc);
+    std::wstring coninPipeNameWStr(coninPipeName);
+    std::string coninPipeNameStr(coninPipeNameWStr.begin(), coninPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+    LPCWSTR conoutPipeName = winpty_conout_name(pc);
+    std::wstring conoutPipeNameWStr(conoutPipeName);
+    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(), conoutPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+  }
+  info.GetReturnValue().Set(marshal);
+
+  goto cleanup;
+
+cleanup:
+  delete filename;
+  delete cmdline;
+  delete cwd;
+}
+
+static NAN_METHOD(PtyResize) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 3 ||
+      !info[0]->IsNumber() ||
+      !info[1]->IsNumber() ||
+      !info[2]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.resize(pid, cols, rows)");
+    return;
+  }
+
+  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int cols = info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int rows = info[2]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  winpty_t *pc = get_pipe_handle(handle);
+
+  if (pc == nullptr) {
+    Nan::ThrowError("The pty doesn't appear to exist");
+    return;
+  }
+  BOOL success = winpty_set_size(pc, cols, rows, nullptr);
+  if (!success) {
+    Nan::ThrowError("The pty could not be resized");
+    return;
+  }
+
+  return info.GetReturnValue().SetUndefined();
+}
+
+static NAN_METHOD(PtyKill) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 2 ||
+      !info[0]->IsNumber() ||
+      !info[1]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.kill(pid, innerPidHandle)");
+    return;
+  }
+
+  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  HANDLE innerPidHandle = (HANDLE)info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  winpty_t *pc = get_pipe_handle(handle);
+  if (pc == nullptr) {
+    Nan::ThrowError("Pty seems to have been killed already");
+    return;
+  }
+
+  assert(remove_pipe_handle(handle));
+  CloseHandle(innerPidHandle);
+
+  return info.GetReturnValue().SetUndefined();
+}
+
+/**
+* Init
+*/
+
+extern "C" void init(v8::Local<v8::Object> target) {
+  Nan::HandleScope scope;
+  Nan::SetMethod(target, "startProcess", PtyStartProcess);
+  Nan::SetMethod(target, "resize", PtyResize);
+  Nan::SetMethod(target, "kill", PtyKill);
+  Nan::SetMethod(target, "getExitCode", PtyGetExitCode);
+  Nan::SetMethod(target, "getProcessList", PtyGetProcessList);
+};
+
+NODE_MODULE(pty, init);

package/vendor/node-pty-fork/src/windowsConoutConnection.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2020, Microsoft Corporation (MIT License).
+ */
+
+import { Worker } from 'worker_threads';
+import { Socket } from 'net';
+import { IDisposable } from './types';
+import { IWorkerData, ConoutWorkerMessage, getWorkerPipeName } from './shared/conout';
+import { join } from 'path';
+import { IEvent, EventEmitter2 } from './eventEmitter2';
+
+/**
+ * The amount of time to wait for additional data after the conpty shell process has exited before
+ * shutting down the worker and sockets. The timer will be reset if a new data event comes in after
+ * the timer has started.
+ */
+const FLUSH_DATA_INTERVAL = 1000;
+
+/**
+ * Connects to and manages the lifecycle of the conout socket. This socket must be drained on
+ * another thread in order to avoid deadlocks where Conpty waits for the out socket to drain
+ * when `ClosePseudoConsole` is called. This happens when data is being written to the terminal when
+ * the pty is closed.
+ *
+ * See also:
+ * - https://github.com/microsoft/node-pty/issues/375
+ * - https://github.com/microsoft/vscode/issues/76548
+ * - https://github.com/microsoft/terminal/issues/1810
+ * - https://docs.microsoft.com/en-us/windows/console/closepseudoconsole
+ */
+export class ConoutConnection implements IDisposable {
+  private _worker: Worker;
+  private _drainTimeout: NodeJS.Timeout | undefined;
+  private _isDisposed: boolean = false;
+
+  private _onReady = new EventEmitter2<void>();
+  public get onReady(): IEvent<void> { return this._onReady.event; }
+
+  constructor(
+    private _conoutPipeName: string
+  ) {
+    const workerData: IWorkerData = { conoutPipeName: _conoutPipeName };
+    const scriptPath = __dirname.replace('node_modules.asar', 'node_modules.asar.unpacked');
+    this._worker = new Worker(join(scriptPath, 'worker/conoutSocketWorker.js'), { workerData });
+    this._worker.on('message', (message: ConoutWorkerMessage) => {
+      switch (message) {
+        case ConoutWorkerMessage.READY:
+          this._onReady.fire();
+          return;
+        default:
+          console.warn('Unexpected ConoutWorkerMessage', message);
+      }
+    });
+  }
+
+  dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    // Drain all data from the socket before closing
+    this._drainDataAndClose();
+  }
+
+  connectSocket(socket: Socket): void {
+    socket.connect(getWorkerPipeName(this._conoutPipeName));
+  }
+
+  private _drainDataAndClose(): void {
+    if (this._drainTimeout) {
+      clearTimeout(this._drainTimeout);
+    }
+    this._drainTimeout = setTimeout(() => this._destroySocket(), FLUSH_DATA_INTERVAL);
+  }
+
+  private async _destroySocket(): Promise<void> {
+    await this._worker.terminate();
+  }
+}

package/vendor/node-pty-fork/src/windowsPtyAgent.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+import * as assert from 'assert';
+import { argsToCommandLine } from './windowsPtyAgent';
+
+function check(file: string, args: string | string[], expected: string): void {
+  assert.equal(argsToCommandLine(file, args), expected);
+}
+
+if (process.platform === 'win32') {
+  describe('argsToCommandLine', () => {
+    describe('Plain strings', () => {
+      it('doesn\'t quote plain string', () => {
+        check('asdf', [], 'asdf');
+      });
+      it('doesn\'t escape backslashes', () => {
+        check('\\asdf\\qwer\\', [], '\\asdf\\qwer\\');
+      });
+      it('doesn\'t escape multiple backslashes', () => {
+        check('asdf\\\\qwer', [], 'asdf\\\\qwer');
+      });
+      it('adds backslashes before quotes', () => {
+        check('"asdf"qwer"', [], '\\"asdf\\"qwer\\"');
+      });
+      it('escapes backslashes before quotes', () => {
+        check('asdf\\"qwer', [], 'asdf\\\\\\"qwer');
+      });
+    });
+
+    describe('Quoted strings', () => {
+      it('quotes string with spaces', () => {
+        check('asdf qwer', [], '"asdf qwer"');
+      });
+      it('quotes empty string', () => {
+        check('', [], '""');
+      });
+      it('quotes string with tabs', () => {
+        check('asdf\tqwer', [], '"asdf\tqwer"');
+      });
+      it('escapes only the last backslash', () => {
+        check('\\asdf \\qwer\\', [], '"\\asdf \\qwer\\\\"');
+      });
+      it('doesn\'t escape multiple backslashes', () => {
+        check('asdf \\\\qwer', [], '"asdf \\\\qwer"');
+      });
+      it('escapes backslashes before quotes', () => {
+        check('asdf \\"qwer', [], '"asdf \\\\\\"qwer"');
+      });
+      it('escapes multiple backslashes at the end', () => {
+        check('asdf qwer\\\\', [], '"asdf qwer\\\\\\\\"');
+      });
+    });
+
+    describe('Multiple arguments', () => {
+      it('joins arguments with spaces', () => {
+        check('asdf', ['qwer zxcv', '', '"'], 'asdf "qwer zxcv" "" \\"');
+      });
+      it('array argument all in quotes', () => {
+        check('asdf', ['"surounded by quotes"'], 'asdf \\"surounded by quotes\\"');
+      });
+      it('array argument quotes in the middle', () => {
+        check('asdf', ['quotes "in the" middle'], 'asdf "quotes \\"in the\\" middle"');
+      });
+      it('array argument quotes near start', () => {
+        check('asdf', ['"quotes" near start'], 'asdf "\\"quotes\\" near start"');
+      });
+      it('array argument quotes near end', () => {
+        check('asdf', ['quotes "near end"'], 'asdf "quotes \\"near end\\""');
+      });
+    });
+
+    describe('Args as CommandLine', () => {
+      it('should handle empty string', () => {
+        check('file', '', 'file');
+      });
+      it('should not change args', () => {
+        check('file', 'foo bar baz', 'file foo bar baz');
+        check('file', 'foo \\ba"r \baz', 'file foo \\ba"r \baz');
+      });
+    });
+
+    describe('Real-world cases', () => {
+      it('quotes within quotes', () => {
+        check('cmd.exe', ['/c', 'powershell -noexit -command \'Set-location \"C:\\user\"\''], 'cmd.exe /c "powershell -noexit -command \'Set-location \\\"C:\\user\\"\'"');
+      });
+      it('space within quotes', () => {
+        check('cmd.exe', ['/k', '"C:\\Users\\alros\\Desktop\\test script.bat"'], 'cmd.exe /k \\"C:\\Users\\alros\\Desktop\\test script.bat\\"');
+      });
+    });
+  });
+}