codexui-android 0.1.93 → 0.1.94

package/node_modules/node-pty/src/win/path_util.cc

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+#include <stdexcept>
+#include <Shlwapi.h> // PathCombine
+#include <Windows.h>
+#include "path_util.h"
+
+namespace path_util {
+
+std::wstring to_wstring(const Napi::String& str) {
+  const std::u16string & u16 = str.Utf16Value();
+  return std::wstring(u16.begin(), u16.end());
+}
+
+std::string wstring_to_string(const std::wstring &wide_string) {
+  if (wide_string.empty()) {
+    return "";
+  }
+  const auto size_needed = WideCharToMultiByte(CP_UTF8, 0, &wide_string.at(0), (int)wide_string.size(), nullptr, 0, nullptr, nullptr);
+  if (size_needed <= 0) {
+    return "";
+  }
+  std::string result(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, &wide_string.at(0), (int)wide_string.size(), &result.at(0), size_needed, nullptr, nullptr);
+  return result;
+}
+
+const char* from_wstring(const wchar_t* wstr) {
+  int bufferSize = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
+  if (bufferSize <= 0) {
+    return "";
+  }
+  char *output = new char[bufferSize];
+  int status = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, output, bufferSize, NULL, NULL);
+  if (status == 0) {
+    return "";
+  }
+  return output;
+}
+
+bool file_exists(std::wstring filename) {
+  DWORD attr = ::GetFileAttributesW(filename.c_str());
+  if (attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY)) {
+    return false;
+  }
+  return true;
+}
+
+// cmd.exe -> C:\Windows\system32\cmd.exe
+std::wstring get_shell_path(std::wstring filename) {
+  std::wstring shellpath;
+
+  if (file_exists(filename)) {
+    return shellpath;
+  }
+
+  wchar_t* buffer_ = new wchar_t[MAX_ENV];
+  int read = ::GetEnvironmentVariableW(L"Path", buffer_, MAX_ENV);
+  if (read) {
+    std::wstring delimiter = L";";
+    size_t pos = 0;
+    std::vector<std::wstring> paths;
+    std::wstring buffer(buffer_);
+    while ((pos = buffer.find(delimiter)) != std::wstring::npos) {
+      paths.push_back(buffer.substr(0, pos));
+      buffer.erase(0, pos + delimiter.length());
+    }
+
+    const wchar_t *filename_ = filename.c_str();
+
+    for (size_t i = 0; i < paths.size(); ++i) {
+      std::wstring path = paths[i];
+      wchar_t searchPath[MAX_PATH];
+      ::PathCombineW(searchPath, const_cast<wchar_t*>(path.c_str()), filename_);
+
+      if (searchPath == NULL) {
+        continue;
+      }
+
+      if (file_exists(searchPath)) {
+        shellpath = searchPath;
+        break;
+      }
+    }
+  }
+
+  delete[] buffer_;
+  return shellpath;
+}
+
+}  // namespace path_util

package/node_modules/node-pty/src/win/path_util.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+#ifndef NODE_PTY_PATH_UTIL_H_
+#define NODE_PTY_PATH_UTIL_H_
+
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
+#include <string>
+
+#define MAX_ENV 65536
+
+namespace path_util {
+
+std::wstring to_wstring(const Napi::String& str);
+std::string wstring_to_string(const std::wstring &wide_string);
+const char* from_wstring(const wchar_t* wstr);
+bool file_exists(std::wstring filename);
+std::wstring get_shell_path(std::wstring filename);
+
+}  // namespace path_util
+
+#endif  // NODE_PTY_PATH_UTIL_H_

package/node_modules/node-pty/src/win/winpty.cc

@@ -0,0 +1,333 @@
+/**
+ * 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.
+ */
+
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
+#include <iostream>
+#include <assert.h>
+#include <map>
+#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
+*/
+#define WINPTY_DBG_VARIABLE TEXT("WINPTYDBG")
+
+/**
+* winpty
+*/
+static std::vector<winpty_t *> ptyHandles;
+static volatile LONG ptyCounter;
+
+/**
+* Helpers
+*/
+
+/** Keeps track of the handles created by PtyStartProcess */
+static std::map<DWORD, HANDLE> createdHandles;
+
+static winpty_t *get_pipe_handle(DWORD pid) {
+  for (size_t i = 0; i < ptyHandles.size(); ++i) {
+    winpty_t *ptyHandle = ptyHandles[i];
+    HANDLE current = winpty_agent_process(ptyHandle);
+    if (GetProcessId(current) == pid) {
+      return ptyHandle;
+    }
+  }
+  return nullptr;
+}
+
+static bool remove_pipe_handle(DWORD pid) {
+  for (size_t i = 0; i < ptyHandles.size(); ++i) {
+    winpty_t *ptyHandle = ptyHandles[i];
+    HANDLE current = winpty_agent_process(ptyHandle);
+    if (GetProcessId(current) == pid) {
+      winpty_free(ptyHandle);
+      ptyHandles.erase(ptyHandles.begin() + i);
+      ptyHandle = nullptr;
+      return true;
+    }
+  }
+  return false;
+}
+
+Napi::Error error_with_winpty_msg(const char *generalMsg, winpty_error_ptr_t error_ptr, Napi::Env env) {
+  std::string why;
+  why += generalMsg;
+  why += ": ";
+  why += path_util::wstring_to_string(winpty_error_msg(error_ptr));
+  winpty_error_free(error_ptr);
+  return Napi::Error::New(env, why);
+}
+
+static Napi::Value PtyGetExitCode(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
+
+  if (info.Length() != 1 ||
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.getExitCode(pid)");
+  }
+
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  HANDLE handle = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
+  if (handle == NULL) {
+    return Napi::Number::New(env, -1);
+  }
+
+  DWORD exitCode = 0;
+  BOOL success = GetExitCodeProcess(handle, &exitCode);
+  if (success == FALSE) {
+    exitCode = -1;
+  }
+
+  CloseHandle(handle);
+  return Napi::Number::New(env, exitCode);
+}
+
+static Napi::Value PtyGetProcessList(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
+
+  if (info.Length() != 1 ||
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.getProcessList(pid)");
+  }
+
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  winpty_t *pc = get_pipe_handle(pid);
+  if (pc == nullptr) {
+    return Napi::Number::New(env, 0);
+  }
+  int processList[64];
+  const int processCount = 64;
+  int actualCount = winpty_get_console_process_list(pc, processList, processCount, nullptr);
+  if (actualCount <= 0) {
+    return Napi::Number::New(env, 0);
+  }
+  Napi::Array result = Napi::Array::New(env, actualCount);
+  for (int i = 0; i < actualCount; i++) {
+    result.Set(i, Napi::Number::New(env, processList[i]));
+  }
+  return result;
+}
+
+static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
+
+  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()) {
+    throw Napi::Error::New(env, "Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
+  }
+
+  std::wstring filename(path_util::to_wstring(info[0].As<Napi::String>()));
+  std::wstring cmdline(path_util::to_wstring(info[1].As<Napi::String>()));
+  std::wstring cwd(path_util::to_wstring(info[3].As<Napi::String>()));
+
+  // create environment block
+  std::wstring envStr;
+  const Napi::Array envValues = info[2].As<Napi::Array>();
+  if (!envValues.IsEmpty()) {
+    std::wstring envBlock;
+    for(uint32_t i = 0; i < envValues.Length(); i++) {
+      envBlock += path_util::to_wstring(envValues.Get(i).As<Napi::String>());
+      envBlock += L'\0';
+    }
+    envStr = std::move(envBlock);
+  }
+
+  // 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.c_str())) {
+    shellpath = path_util::get_shell_path(filename);
+  } else {
+    shellpath = filename;
+  }
+
+  if (shellpath.empty() || !path_util::file_exists(shellpath)) {
+    std::string why;
+    why += "File not found: ";
+    why += path_util::wstring_to_string(shellpath);
+    throw Napi::Error::New(env, why);
+  }
+
+  int cols = info[4].As<Napi::Number>().Int32Value();
+  int rows = info[5].As<Napi::Number>().Int32Value();
+  bool debug = info[6].As<Napi::Boolean>().Value();
+
+  // Enable/disable debugging
+  SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
+
+  // Create winpty config
+  winpty_error_ptr_t error_ptr = nullptr;
+  winpty_config_t* winpty_config = winpty_config_new(0, &error_ptr);
+  if (winpty_config == nullptr) {
+    throw error_with_winpty_msg("Error creating WinPTY config", error_ptr, env);
+  }
+  winpty_error_free(error_ptr);
+
+  // Set pty size on config
+  winpty_config_set_initial_size(winpty_config, cols, rows);
+
+  // Start the pty agent
+  winpty_t *pc = winpty_open(winpty_config, &error_ptr);
+  winpty_config_free(winpty_config);
+  if (pc == nullptr) {
+    throw error_with_winpty_msg("Error launching WinPTY agent", error_ptr, env);
+  }
+  winpty_error_free(error_ptr);
+
+  // Create winpty spawn config
+  winpty_spawn_config_t* config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline.c_str(), cwd.c_str(), envStr.c_str(), &error_ptr);
+  if (config == nullptr) {
+    winpty_free(pc);
+    throw error_with_winpty_msg("Error creating WinPTY spawn config", error_ptr, env);
+  }
+  winpty_error_free(error_ptr);
+
+  // Spawn the new process
+  HANDLE handle = nullptr;
+  BOOL spawnSuccess = winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
+  winpty_spawn_config_free(config);
+  if (!spawnSuccess) {
+    if (handle) {
+      CloseHandle(handle);
+    }
+    winpty_free(pc);
+    throw error_with_winpty_msg("Unable to start terminal process", error_ptr, env);
+  }
+  winpty_error_free(error_ptr);
+
+  LPCWSTR coninPipeName = winpty_conin_name(pc);
+  std::string coninPipeNameStr(path_util::from_wstring(coninPipeName));
+  if (coninPipeNameStr.empty()) {
+    CloseHandle(handle);
+    winpty_free(pc);
+    throw Napi::Error::New(env, "Failed to initialize winpty conin");
+  }
+
+  LPCWSTR conoutPipeName = winpty_conout_name(pc);
+  std::string conoutPipeNameStr(path_util::from_wstring(conoutPipeName));
+  if (conoutPipeNameStr.empty()) {
+    CloseHandle(handle);
+    winpty_free(pc);
+    throw Napi::Error::New(env, "Failed to initialize winpty conout");
+  }
+
+  DWORD innerPid = GetProcessId(handle);
+  if (createdHandles[innerPid]) {
+    CloseHandle(handle);
+    winpty_free(pc);
+    std::stringstream why;
+    why << "There is already a process with innerPid " << innerPid;
+    throw Napi::Error::New(env, why.str());
+  }
+  createdHandles[innerPid] = handle;
+
+  // Save pty struct for later use
+  ptyHandles.push_back(pc);
+
+  DWORD pid = GetProcessId(winpty_agent_process(pc));
+  Napi::Object marshal = Napi::Object::New(env);
+  marshal.Set("innerPid", Napi::Number::New(env, (int)innerPid));
+  marshal.Set("pid", Napi::Number::New(env, (int)pid));
+  marshal.Set("pty", Napi::Number::New(env, InterlockedIncrement(&ptyCounter)));
+  marshal.Set("fd", Napi::Number::New(env, -1));
+  marshal.Set("conin", Napi::String::New(env, coninPipeNameStr));
+  marshal.Set("conout", Napi::String::New(env, conoutPipeNameStr));
+
+  return marshal;
+}
+
+static Napi::Value PtyResize(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
+
+  if (info.Length() != 3 ||
+      !info[0].IsNumber() ||
+      !info[1].IsNumber() ||
+      !info[2].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.resize(pid, cols, rows)");
+  }
+
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  int cols = info[1].As<Napi::Number>().Int32Value();
+  int rows = info[2].As<Napi::Number>().Int32Value();
+
+  winpty_t *pc = get_pipe_handle(pid);
+
+  if (pc == nullptr) {
+    throw Napi::Error::New(env, "The pty doesn't appear to exist");
+  }
+  BOOL success = winpty_set_size(pc, cols, rows, nullptr);
+  if (!success) {
+    throw Napi::Error::New(env, "The pty could not be resized");
+  }
+
+  return env.Undefined();
+}
+
+static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
+
+  if (info.Length() != 2 ||
+      !info[0].IsNumber() ||
+      !info[1].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.kill(pid, innerPid)");
+  }
+
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  DWORD innerPid = info[1].As<Napi::Number>().Uint32Value();
+
+  winpty_t *pc = get_pipe_handle(pid);
+  if (pc == nullptr) {
+    throw Napi::Error::New(env, "Pty seems to have been killed already");
+  }
+
+  assert(remove_pipe_handle(pid));
+
+  HANDLE innerPidHandle = createdHandles[innerPid];
+  createdHandles.erase(innerPid);
+  CloseHandle(innerPidHandle);
+
+  return env.Undefined();
+}
+
+/**
+* Init
+*/
+
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  exports.Set("startProcess", Napi::Function::New(env, PtyStartProcess));
+  exports.Set("resize", Napi::Function::New(env, PtyResize));
+  exports.Set("kill", Napi::Function::New(env, PtyKill));
+  exports.Set("getExitCode", Napi::Function::New(env, PtyGetExitCode));
+  exports.Set("getProcessList", Napi::Function::New(env, PtyGetProcessList));
+  return exports;
+};
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, init);

package/node_modules/node-pty/src/windowsConoutConnection.ts

@@ -0,0 +1,82 @@
+/**
+ * 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,
+    private _useConptyDll: boolean
+  ) {
+    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._useConptyDll && 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/node_modules/node-pty/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\\"');
+      });
+    });
+  });
+}