codexui-android 0.1.92 → 0.1.94

package/node_modules/node-pty/deps/winpty/src/agent/Win32ConsoleBuffer.cc

@@ -0,0 +1,193 @@
+// Copyright (c) 2011-2016 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#include "Win32ConsoleBuffer.h"
+
+#include <windows.h>
+
+#include "../shared/DebugClient.h"
+#include "../shared/StringBuilder.h"
+#include "../shared/WinptyAssert.h"
+
+std::unique_ptr<Win32ConsoleBuffer> Win32ConsoleBuffer::openStdout() {
+    return std::unique_ptr<Win32ConsoleBuffer>(
+        new Win32ConsoleBuffer(GetStdHandle(STD_OUTPUT_HANDLE), false));
+}
+
+std::unique_ptr<Win32ConsoleBuffer> Win32ConsoleBuffer::openConout() {
+    const HANDLE conout = CreateFileW(L"CONOUT$",
+                                      GENERIC_READ | GENERIC_WRITE,
+                                      FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                      NULL, OPEN_EXISTING, 0, NULL);
+    ASSERT(conout != INVALID_HANDLE_VALUE);
+    return std::unique_ptr<Win32ConsoleBuffer>(
+        new Win32ConsoleBuffer(conout, true));
+}
+
+std::unique_ptr<Win32ConsoleBuffer> Win32ConsoleBuffer::createErrorBuffer() {
+    SECURITY_ATTRIBUTES sa = {};
+    sa.nLength = sizeof(sa);
+    sa.bInheritHandle = TRUE;
+    const HANDLE conout =
+        CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
+                                  FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                  &sa,
+                                  CONSOLE_TEXTMODE_BUFFER,
+                                  nullptr);
+    ASSERT(conout != INVALID_HANDLE_VALUE);
+    return std::unique_ptr<Win32ConsoleBuffer>(
+        new Win32ConsoleBuffer(conout, true));
+}
+
+HANDLE Win32ConsoleBuffer::conout() {
+    return m_conout;
+}
+
+void Win32ConsoleBuffer::clearLines(
+        int row,
+        int count,
+        const ConsoleScreenBufferInfo &info) {
+    // TODO: error handling
+    const int width = info.bufferSize().X;
+    DWORD actual = 0;
+    if (!FillConsoleOutputCharacterW(
+            m_conout, L' ', width * count, Coord(0, row),
+            &actual) || static_cast<int>(actual) != width * count) {
+        trace("FillConsoleOutputCharacterW failed");
+    }
+    if (!FillConsoleOutputAttribute(
+            m_conout, kDefaultAttributes, width * count, Coord(0, row),
+            &actual) || static_cast<int>(actual) != width * count) {
+        trace("FillConsoleOutputAttribute failed");
+    }
+}
+
+void Win32ConsoleBuffer::clearAllLines(const ConsoleScreenBufferInfo &info) {
+    clearLines(0, info.bufferSize().Y, info);
+}
+
+ConsoleScreenBufferInfo Win32ConsoleBuffer::bufferInfo() {
+    // TODO: error handling
+    ConsoleScreenBufferInfo info;
+    if (!GetConsoleScreenBufferInfo(m_conout, &info)) {
+        trace("GetConsoleScreenBufferInfo failed");
+    }
+    return info;
+}
+
+Coord Win32ConsoleBuffer::bufferSize() {
+    return bufferInfo().bufferSize();
+}
+
+SmallRect Win32ConsoleBuffer::windowRect() {
+    return bufferInfo().windowRect();
+}
+
+bool Win32ConsoleBuffer::resizeBufferRange(const Coord &initialSize,
+                                           Coord &finalSize) {
+    if (SetConsoleScreenBufferSize(m_conout, initialSize)) {
+        finalSize = initialSize;
+        return true;
+    }
+    // The font might be too small to accommodate a very narrow console window.
+    // In that case, rather than simply give up, it's better to try wider
+    // buffer sizes until the call succeeds.
+    Coord size = initialSize;
+    while (size.X < 20) {
+        size.X++;
+        if (SetConsoleScreenBufferSize(m_conout, size)) {
+            finalSize = size;
+            trace("SetConsoleScreenBufferSize: initial size (%d,%d) failed, "
+                  "but wider size (%d,%d) succeeded",
+                  initialSize.X, initialSize.Y,
+                  finalSize.X, finalSize.Y);
+            return true;
+        }
+    }
+    trace("SetConsoleScreenBufferSize failed: "
+          "tried (%d,%d) through (%d,%d)",
+          initialSize.X, initialSize.Y,
+          size.X, size.Y);
+    return false;
+}
+
+void Win32ConsoleBuffer::resizeBuffer(const Coord &size) {
+    // TODO: error handling
+    if (!SetConsoleScreenBufferSize(m_conout, size)) {
+        trace("SetConsoleScreenBufferSize failed: size=(%d,%d)",
+              size.X, size.Y);
+    }
+}
+
+void Win32ConsoleBuffer::moveWindow(const SmallRect &rect) {
+    // TODO: error handling
+    if (!SetConsoleWindowInfo(m_conout, TRUE, &rect)) {
+        trace("SetConsoleWindowInfo failed");
+    }
+}
+
+Coord Win32ConsoleBuffer::cursorPosition() {
+    return bufferInfo().dwCursorPosition;
+}
+
+void Win32ConsoleBuffer::setCursorPosition(const Coord &coord) {
+    // TODO: error handling
+    if (!SetConsoleCursorPosition(m_conout, coord)) {
+        trace("SetConsoleCursorPosition failed");
+    }
+}
+
+void Win32ConsoleBuffer::read(const SmallRect &rect, CHAR_INFO *data) {
+    // TODO: error handling
+    SmallRect tmp(rect);
+    if (!ReadConsoleOutputW(m_conout, data, rect.size(), Coord(), &tmp) &&
+            isTracingEnabled()) {
+        StringBuilder sb(256);
+        auto outStruct = [&](const SMALL_RECT &sr) {
+            sb << "{L=" << sr.Left << ",T=" << sr.Top
+               << ",R=" << sr.Right << ",B=" << sr.Bottom << '}';
+        };
+        sb << "Win32ConsoleBuffer::read: ReadConsoleOutput failed: readRegion=";
+        outStruct(rect);
+        CONSOLE_SCREEN_BUFFER_INFO info = {};
+        if (GetConsoleScreenBufferInfo(m_conout, &info)) {
+            sb << ", dwSize=(" << info.dwSize.X << ',' << info.dwSize.Y
+               << "), srWindow=";
+            outStruct(info.srWindow);
+        } else {
+            sb << ", GetConsoleScreenBufferInfo also failed";
+        }
+        trace("%s", sb.c_str());
+    }
+}
+
+void Win32ConsoleBuffer::write(const SmallRect &rect, const CHAR_INFO *data) {
+    // TODO: error handling
+    SmallRect tmp(rect);
+    if (!WriteConsoleOutputW(m_conout, data, rect.size(), Coord(), &tmp)) {
+        trace("WriteConsoleOutput failed");
+    }
+}
+
+void Win32ConsoleBuffer::setTextAttribute(WORD attributes) {
+    if (!SetConsoleTextAttribute(m_conout, attributes)) {
+        trace("SetConsoleTextAttribute failed");
+    }
+}

package/node_modules/node-pty/deps/winpty/src/agent/Win32ConsoleBuffer.h

@@ -0,0 +1,99 @@
+// Copyright (c) 2011-2016 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#ifndef AGENT_WIN32_CONSOLE_BUFFER_H
+#define AGENT_WIN32_CONSOLE_BUFFER_H
+
+#include <windows.h>
+
+#include <string.h>
+
+#include <memory>
+
+#include "Coord.h"
+#include "SmallRect.h"
+
+class ConsoleScreenBufferInfo : public CONSOLE_SCREEN_BUFFER_INFO {
+public:
+    ConsoleScreenBufferInfo()
+    {
+        memset(this, 0, sizeof(*this));
+    }
+
+    Coord bufferSize() const        { return dwSize;    }
+    SmallRect windowRect() const    { return srWindow;  }
+    Coord cursorPosition() const    { return dwCursorPosition; }
+};
+
+class Win32ConsoleBuffer {
+private:
+    Win32ConsoleBuffer(HANDLE conout, bool owned) :
+        m_conout(conout), m_owned(owned)
+    {
+    }
+
+public:
+    static const int kDefaultAttributes = 7;
+
+    ~Win32ConsoleBuffer() {
+        if (m_owned) {
+            CloseHandle(m_conout);
+        }
+    }
+
+    static std::unique_ptr<Win32ConsoleBuffer> openStdout();
+    static std::unique_ptr<Win32ConsoleBuffer> openConout();
+    static std::unique_ptr<Win32ConsoleBuffer> createErrorBuffer();
+
+    Win32ConsoleBuffer(const Win32ConsoleBuffer &other) = delete;
+    Win32ConsoleBuffer &operator=(const Win32ConsoleBuffer &other) = delete;
+
+    HANDLE conout();
+    void clearLines(int row, int count, const ConsoleScreenBufferInfo &info);
+    void clearAllLines(const ConsoleScreenBufferInfo &info);
+
+    // Buffer and window sizes.
+    ConsoleScreenBufferInfo bufferInfo();
+    Coord bufferSize();
+    SmallRect windowRect();
+    void resizeBuffer(const Coord &size);
+    bool resizeBufferRange(const Coord &initialSize, Coord &finalSize);
+    bool resizeBufferRange(const Coord &initialSize) {
+        Coord dummy;
+        return resizeBufferRange(initialSize, dummy);
+    }
+    void moveWindow(const SmallRect &rect);
+
+    // Cursor.
+    Coord cursorPosition();
+    void setCursorPosition(const Coord &point);
+
+    // Screen content.
+    void read(const SmallRect &rect, CHAR_INFO *data);
+    void write(const SmallRect &rect, const CHAR_INFO *data);
+
+    void setTextAttribute(WORD attributes);
+
+private:
+    HANDLE m_conout = nullptr;
+    bool m_owned = false;
+};
+
+#endif // AGENT_WIN32_CONSOLE_BUFFER_H

package/node_modules/node-pty/deps/winpty/src/agent/main.cc

@@ -0,0 +1,114 @@
+// Copyright (c) 2011-2015 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+#include "../shared/StringUtil.h"
+#include "../shared/WindowsVersion.h"
+#include "../shared/WinptyAssert.h"
+#include "../shared/WinptyVersion.h"
+
+#include "Agent.h"
+#include "AgentCreateDesktop.h"
+#include "DebugShowInput.h"
+
+const char USAGE[] =
+"Usage: %ls controlPipeName flags mouseMode cols rows\n"
+"Usage: %ls controlPipeName --create-desktop\n"
+"\n"
+"Ordinarily, this program is launched by winpty.dll and is not directly\n"
+"useful to winpty users.  However, it also has options intended for\n"
+"debugging winpty.\n"
+"\n"
+"Usage: %ls [options]\n"
+"\n"
+"Options:\n"
+"  --show-input [--with-mouse] [--escape-input]\n"
+"                   Dump INPUT_RECORDs from the console input buffer\n"
+"                   --with-mouse: Include MOUSE_INPUT_RECORDs in the dump\n"
+"                       output\n"
+"                   --escape-input: Direct the new Windows 10 console to use\n"
+"                       escape sequences for input\n"
+"  --version        Print the winpty version\n";
+
+static uint64_t winpty_atoi64(const char *str) {
+    return strtoll(str, NULL, 10);
+}
+
+int main() {
+    dumpWindowsVersion();
+    dumpVersionToTrace();
+
+    // Technically, we should free the CommandLineToArgvW return value using
+    // a single call to LocalFree, but the call will never actually happen in
+    // the normal case.
+    int argc = 0;
+    wchar_t *cmdline = GetCommandLineW();
+    ASSERT(cmdline != nullptr && "GetCommandLineW returned NULL");
+    wchar_t **argv = CommandLineToArgvW(cmdline, &argc);
+    ASSERT(argv != nullptr && "CommandLineToArgvW returned NULL");
+
+    if (argc == 2 && !wcscmp(argv[1], L"--version")) {
+        dumpVersionToStdout();
+        return 0;
+    }
+
+    if (argc >= 2 && !wcscmp(argv[1], L"--show-input")) {
+        bool withMouse = false;
+        bool escapeInput = false;
+        for (int i = 2; i < argc; ++i) {
+            if (!wcscmp(argv[i], L"--with-mouse")) {
+                withMouse = true;
+            } else if (!wcscmp(argv[i], L"--escape-input")) {
+                escapeInput = true;
+            } else {
+                fprintf(stderr, "Unrecognized --show-input option: %ls\n",
+                    argv[i]);
+                return 1;
+            }
+        }
+        debugShowInput(withMouse, escapeInput);
+        return 0;
+    }
+
+    if (argc == 3 && !wcscmp(argv[2], L"--create-desktop")) {
+        handleCreateDesktop(argv[1]);
+        return 0;
+    }
+
+    if (argc != 6) {
+        fprintf(stderr, USAGE, argv[0], argv[0], argv[0]);
+        return 1;
+    }
+
+    Agent agent(argv[1],
+                winpty_atoi64(utf8FromWide(argv[2]).c_str()),
+                atoi(utf8FromWide(argv[3]).c_str()),
+                atoi(utf8FromWide(argv[4]).c_str()),
+                atoi(utf8FromWide(argv[5]).c_str()));
+    agent.run();
+
+    // The Agent destructor shouldn't return, but if it does, exit
+    // unsuccessfully.
+    return 1;
+}

package/node_modules/node-pty/deps/winpty/src/agent/subdir.mk

@@ -0,0 +1,61 @@
+# Copyright (c) 2011-2015 Ryan Prichard
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+ALL_TARGETS += build/winpty-agent.exe
+
+$(eval $(call def_mingw_target,agent,-DWINPTY_AGENT_ASSERT))
+
+AGENT_OBJECTS = \
+	build/agent/agent/Agent.o \
+	build/agent/agent/AgentCreateDesktop.o \
+	build/agent/agent/ConsoleFont.o \
+	build/agent/agent/ConsoleInput.o \
+	build/agent/agent/ConsoleInputReencoding.o \
+	build/agent/agent/ConsoleLine.o \
+	build/agent/agent/DebugShowInput.o \
+	build/agent/agent/DefaultInputMap.o \
+	build/agent/agent/EventLoop.o \
+	build/agent/agent/InputMap.o \
+	build/agent/agent/LargeConsoleRead.o \
+	build/agent/agent/NamedPipe.o \
+	build/agent/agent/Scraper.o \
+	build/agent/agent/Terminal.o \
+	build/agent/agent/Win32Console.o \
+	build/agent/agent/Win32ConsoleBuffer.o \
+	build/agent/agent/main.o \
+	build/agent/shared/BackgroundDesktop.o \
+	build/agent/shared/Buffer.o \
+	build/agent/shared/DebugClient.o \
+	build/agent/shared/GenRandom.o \
+	build/agent/shared/OwnedHandle.o \
+	build/agent/shared/StringUtil.o \
+	build/agent/shared/WindowsSecurity.o \
+	build/agent/shared/WindowsVersion.o \
+	build/agent/shared/WinptyAssert.o \
+	build/agent/shared/WinptyException.o \
+	build/agent/shared/WinptyVersion.o
+
+build/agent/shared/WinptyVersion.o : build/gen/GenVersion.h
+
+build/winpty-agent.exe : $(AGENT_OBJECTS)
+	$(info Linking $@)
+	@$(MINGW_CXX) $(MINGW_LDFLAGS) -o $@ $^
+
+-include $(AGENT_OBJECTS:.o=.d)

package/node_modules/node-pty/deps/winpty/src/configurations.gypi

@@ -0,0 +1,60 @@
+# By default gyp/msbuild build for 32-bit Windows.  This gyp include file
+# defines configurations for both 32-bit and 64-bit Windows.  To use it, run:
+#
+#     C:\...\winpty\src>gyp -I configurations.gypi
+#
+# This command generates Visual Studio project files with a Release
+# configuration and two Platforms--Win32 and x64.  Both can be built:
+#
+#     C:\...\winpty\src>msbuild winpty.sln /p:Platform=Win32
+#     C:\...\winpty\src>msbuild winpty.sln /p:Platform=x64
+#
+# The output is placed in:
+#
+#     C:\...\winpty\src\Release\Win32
+#     C:\...\winpty\src\Release\x64
+#
+# Windows XP note: By default, the project files will use the default "toolset"
+# for the given MSVC version.  For MSVC 2013 and MSVC 2015, the default toolset
+# generates binaries that do not run on Windows XP.  To target Windows XP,
+# select the XP-specific toolset by passing
+# -D WINPTY_MSBUILD_TOOLSET={v120_xp,v140_xp} to gyp (v120_xp == MSVC 2013,
+# v140_xp == MSVC 2015).  Unfortunately, it isn't possible to have a single
+# project file with configurations for both XP and post-XP.  This seems to be a
+# limitation of the MSVC project file format.
+#
+# This file is not included by default, because I suspect it would interfere
+# with node-gyp, which has a different system for building 32-vs-64-bit
+# binaries.  It uses a common.gypi, and the project files it generates can only
+# build a single architecture, the output paths are not differentiated by
+# architecture.
+
+{
+    'variables': {
+        'WINPTY_MSBUILD_TOOLSET%': '',
+    },
+    'target_defaults': {
+        'default_configuration': 'Release_Win32',
+        'configurations': {
+            'Release_Win32': {
+                'msvs_configuration_platform': 'Win32',
+            },
+            'Release_x64': {
+                'msvs_configuration_platform': 'x64',
+            },
+        },
+        'msvs_configuration_attributes': {
+            'OutputDirectory': '$(SolutionDir)$(ConfigurationName)\\$(Platform)',
+            'IntermediateDirectory': '$(ConfigurationName)\\$(Platform)\\obj\\$(ProjectName)',
+        },
+        'msvs_settings': {
+            'VCLinkerTool': {
+                'SubSystem': '1', # /SUBSYSTEM:CONSOLE
+            },
+            'VCCLCompilerTool': {
+                'RuntimeLibrary': '0', # MultiThreaded (/MT)
+            },
+        },
+        'msbuild_toolset' : '<(WINPTY_MSBUILD_TOOLSET)',
+    }
+}

package/node_modules/node-pty/deps/winpty/src/debugserver/DebugServer.cc

@@ -0,0 +1,117 @@
+// Copyright (c) 2015 Ryan Prichard
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <windows.h>
+
+#include "../shared/WindowsSecurity.h"
+#include "../shared/WinptyException.h"
+
+const wchar_t *kPipeName = L"\\\\.\\pipe\\DebugServer";
+
+// A message may not be larger than this size.
+const int MSG_SIZE = 4096;
+
+static void usage(const char *program, int code) {
+    printf("Usage: %s [--everyone]\n"
+           "\n"
+           "Creates the named pipe %ls and reads messages.  Prints each\n"
+           "message to stdout.  By default, only the current user can send messages.\n"
+           "Pass --everyone to let anyone send a message.\n"
+           "\n"
+           "Use the WINPTY_DEBUG environment variable to enable winpty trace output.\n"
+           "(e.g. WINPTY_DEBUG=trace for the default trace output.)  Set WINPTYDBG=1\n"
+           "to enable trace with older winpty versions.\n",
+           program, kPipeName);
+    exit(code);
+}
+
+int main(int argc, char *argv[]) {
+    bool everyone = false;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--everyone") {
+            everyone = true;
+        } else if (arg == "-h" || arg == "--help") {
+            usage(argv[0], 0);
+        } else {
+            usage(argv[0], 1);
+        }
+    }
+
+    SecurityDescriptor sd;
+    PSECURITY_ATTRIBUTES psa = nullptr;
+    SECURITY_ATTRIBUTES sa = {};
+    if (everyone) {
+        try {
+            sd = createPipeSecurityDescriptorOwnerFullControlEveryoneWrite();
+        } catch (const WinptyException &e) {
+            fprintf(stderr,
+                "error creating security descriptor: %ls\n", e.what());
+            exit(1);
+        }
+        sa.nLength = sizeof(sa);
+        sa.lpSecurityDescriptor = sd.get();
+        psa = &sa;
+    }
+
+    HANDLE serverPipe = CreateNamedPipeW(
+        kPipeName,
+        /*dwOpenMode=*/PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE,
+        /*dwPipeMode=*/PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE |
+            rejectRemoteClientsPipeFlag(),
+        /*nMaxInstances=*/1,
+        /*nOutBufferSize=*/MSG_SIZE,
+        /*nInBufferSize=*/MSG_SIZE,
+        /*nDefaultTimeOut=*/10 * 1000,
+        psa);
+
+    if (serverPipe == INVALID_HANDLE_VALUE) {
+        fprintf(stderr, "error: could not create %ls pipe: error %u\n",
+            kPipeName, static_cast<unsigned>(GetLastError()));
+        exit(1);
+    }
+
+    char msgBuffer[MSG_SIZE + 1];
+
+    while (true) {
+        if (!ConnectNamedPipe(serverPipe, nullptr)) {
+            fprintf(stderr, "error: ConnectNamedPipe failed\n");
+            fflush(stderr);
+            exit(1);
+        }
+        DWORD bytesRead = 0;
+        if (!ReadFile(serverPipe, msgBuffer, MSG_SIZE, &bytesRead, nullptr)) {
+            fprintf(stderr, "error: ReadFile on pipe failed\n");
+            fflush(stderr);
+            DisconnectNamedPipe(serverPipe);
+            continue;
+        }
+        msgBuffer[bytesRead] = '\n';
+        fwrite(msgBuffer, 1, bytesRead + 1, stdout);
+        fflush(stdout);
+
+        DWORD bytesWritten = 0;
+        WriteFile(serverPipe, "OK", 2, &bytesWritten, nullptr);
+        DisconnectNamedPipe(serverPipe);
+    }
+}

package/node_modules/node-pty/deps/winpty/src/debugserver/subdir.mk

@@ -0,0 +1,41 @@
+# Copyright (c) 2015 Ryan Prichard
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+ALL_TARGETS += build/winpty-debugserver.exe
+
+$(eval $(call def_mingw_target,debugserver,))
+
+DEBUGSERVER_OBJECTS = \
+	build/debugserver/debugserver/DebugServer.o \
+	build/debugserver/shared/DebugClient.o \
+	build/debugserver/shared/OwnedHandle.o \
+	build/debugserver/shared/StringUtil.o \
+	build/debugserver/shared/WindowsSecurity.o \
+	build/debugserver/shared/WindowsVersion.o \
+	build/debugserver/shared/WinptyAssert.o \
+	build/debugserver/shared/WinptyException.o
+
+build/debugserver/shared/WindowsVersion.o : build/gen/GenVersion.h
+
+build/winpty-debugserver.exe : $(DEBUGSERVER_OBJECTS)
+	$(info Linking $@)
+	@$(MINGW_CXX) $(MINGW_LDFLAGS) -o $@ $^
+
+-include $(DEBUGSERVER_OBJECTS:.o=.d)