@netcuras/nodejs-winrm 1.3.3

package/.travis.yml

@@ -0,0 +1,15 @@
+language: node_js
+
+node_js:
+  - "11"
+  - "10"
+  - "9"
+  - "8"
+
+os:
+  - linux
+  - osx
+  - windows
+    
+after_success:
+  - './node_modules/.bin/nyc report --reporter=text-lcov | ./node_modules/.bin/coveralls'  

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Shone
+
+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.

package/README.md

@@ -0,0 +1,94 @@
+# nodejs-winrm
+
+[![npm version](https://badge.fury.io/js/nodejs-winrm.svg)](https://badge.fury.io/js/nodejs-winrm)
+[![Build Status](https://travis-ci.org/shoneslab/nodejs-winrm.svg?branch=master)](https://travis-ci.org/shoneslab/nodejs-winrm)
+[![Build Status](https://dev.azure.com/SHONEJACOB/SHONEJACOB/_apis/build/status/shoneslab.nodejs-winrm?branchName=master)](https://dev.azure.com/SHONEJACOB/SHONEJACOB/_build/latest?definitionId=1?branchName=master)
+
+nodejs-winrm is a NodeJS client to access WinRM (Windows Remote Management) SOAP web service. It allows to execute commands on target windows machines.
+Please visit [Microsoft's WinRM site](http://msdn.microsoft.com/en-us/library/aa384426.aspx) for WINRM details.
+
+## Supported NodeJS Versions
+
+Tested on NodeJS Version > 8.11
+
+## Supported WinRM Versions
+
+As of now Winrm Version 3 is tested.
+
+```
+> winrm id
+
+IdentifyResponse
+    ProtocolVersion = http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd
+    ProductVendor = Microsoft Corporation
+    ProductVersion = OS: 10.0.xxxx SP: 0.0 Stack: 3.0
+```
+
+## Install
+
+On the remote host, a PowerShell prompt, using the __Run as Administrator__ option and paste in the following lines:
+
+```
+> winrm quickconfig
+y
+> winrm set winrm/config/service/Auth '@{Basic="true"}'
+> winrm set winrm/config/service '@{AllowUnencrypted="true"}'
+> winrm set winrm/config/winrs '@{MaxMemoryPerShellMB="1024"}'
+```
+On the client side where NodeJS is installed
+
+`npm install nodejs-winrm`
+
+## Examples
+
+### Run a Single Command 
+```
+var winrm = require('nodejs-winrm');
+winrm.runCommand('mkdir D:\\winrmtest001', '10.xxx.xxx.xxx', 'username', 'password', 5985);
+winrm.runCommand('ipconfig /all', '10.xxx.xxx.xxx', 'username', 'password', 5985);
+```
+### Run multiple Commands (Advanced)
+```
+var winrm = require('nodejs-winrm');
+
+var userName = 'userName';
+var password = 'password';
+var _host = '10.xxx.xxx.xxx';
+var _port = 5985;
+
+var auth = 'Basic ' + Buffer.from(userName + ":" + password, 'utf8').toString('base64');
+var params = {
+    host: _host,
+    port: _port,
+    path: '/wsman'
+};
+params['auth'] = auth;
+
+//Get the Shell ID
+params['shellId']= await winrm.shell.doCreateShell(params);
+
+// Execute Command1
+params['command'] = 'ipconfig /all';
+params['commandId'] = await winrm.command.doExecuteCommand(params);
+var result1= await winrm.command.doReceiveOutput(params);
+
+// Execute Command2
+params['command'] = 'mkdir D:\\winrmtest001';
+params['commandId'] = await winrm.command.doExecuteCommand(params);
+var result2= await winrm.command.doReceiveOutput(params);
+
+// Close the Shell
+await winrm.shell.doDeleteShell(params);
+
+```
+
+
+## Testing
+
+`npm test`
+
+## Maintainers
+* Shone Jacob (https://github.com/shoneslab)
+
+## Credits
+* https://github.com/jacobludriks/winrmjs

package/azure-pipelines.yml

@@ -0,0 +1,20 @@
+# Node.js
+# Build a general Node.js project with npm.
+# Add steps that analyze code, save build artifacts, deploy, and more:
+# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript
+
+trigger:
+- master
+
+pool:
+  vmImage: 'Ubuntu-16.04'
+
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: '8.x'
+  displayName: 'Install Node.js'
+
+- script: |
+    npm install
+  displayName: 'npm install and build'

package/eslint.config.js

@@ -0,0 +1,31 @@
+const js = require('@eslint/js');
+const globals = require('globals');
+
+module.exports = [
+    {
+        ignores: ['coverage/**']
+    },
+    js.configs.recommended,
+    {
+        languageOptions: {
+            ecmaVersion: 2022,
+            sourceType: 'commonjs',
+            globals: {
+                ...globals.node,
+                ...globals.browser
+            }
+        },
+        rules: {
+            'no-console': 'off',
+            'linebreak-style': ['error', 'unix'],
+            quotes: ['error', 'single'],
+            semi: ['error', 'always']
+        }
+    },
+    {
+        files: ['test/**/*.spec.js', '__tests__/**/*.spec.js'],
+        languageOptions: {
+            globals: globals.jest
+        }
+    }
+];

package/examples/test.js

@@ -0,0 +1,13 @@
+var winrm = require('../index.js');
+
+async function performOneCommand() {
+    try {
+        //var result = await winrm.runCommand('mkdir D:\\winrmtest001', '10.xxx.xxx.xxx', 5985, 'username', 'password');
+        var result = await winrm.runCommand('ipconfig /all', '10.xxx.xxx.xxx', 'username', 'password', 5985);
+        console.log(result);
+    } catch (error) {
+        console.error(`Exception Occurred: ${error}`);
+    }
+}
+
+performOneCommand();

package/index.js

@@ -0,0 +1,48 @@
+let shell = require('./src/shell.js');
+let command = require('./src/command.js');
+let enumerate = require('./src/enumerate.js');
+let invoke = require('./src/invoke.js');
+
+module.exports = {
+    shell: shell,
+    command: command,
+    enumerate: enumerate,
+    invoke: invoke
+};
+
+module.exports.runCommand = async function (_command, _host, _username, _password, _port, _usePowershell = false) {
+    try {
+        var auth = 'Basic ' + Buffer.from(_username + ':' + _password, 'utf8').toString('base64');
+        var params = {
+            host: _host,
+            port: _port,
+            path: '/wsman',
+        };
+        params['auth'] = auth;
+        var shellId = await shell.doCreateShell(params);
+        params['shellId'] = shellId;
+    
+        params['command'] = _command;
+        var commandId;
+        if ( _usePowershell ) {
+            commandId = await command.doExecutePowershell(params);
+        } else {
+            commandId = await command.doExecuteCommand(params);
+        }
+    
+        params['commandId'] = commandId;
+        var output = await command.doReceiveOutput(params);
+    
+        await shell.doDeleteShell(params);
+    
+        return output;
+    } catch (error) {
+        console.log('error', error);
+        return error;
+    }   
+   
+};
+
+module.exports.runPowershell = async function (_command, _host, _username, _password, _port) {
+  return module.exports.runCommand(_command, _host, _username, _password, _port, true);
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@netcuras/nodejs-winrm",
+  "version": "1.3.3",
+  "description": "Make WinRM service calls from NodeJS",
+  "main": "index.js",
+  "scripts": {
+    "test": "node ./test/test.js",
+    "outdated": "npm outdated --json || true",
+    "lint": "npx eslint .",
+    "jest:test": "jest",
+    "jest:coverage": "npx jest --coverage",
+    "jest:watch": "jest --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shoneslab/nodejs-winrm.git"
+  },
+  "keywords": [
+    "winrm"
+  ],
+  "author": "Shone Jacob",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shoneslab/nodejs-winrm/issues"
+  },
+  "homepage": "https://github.com/shoneslab/nodejs-winrm#readme",
+  "jest": {
+    "automock": false,
+    "coveragePathIgnorePatterns": [],
+    "verbose": true,
+    "coverageReporters": [
+      "html",
+      "lcov",
+      "json",
+      "text",
+      "text-summary"
+    ],
+    "testMatch": [
+      "<rootDir>/test/*.unit.spec.js",
+      "<rootDir>/__tests__/*.unit.spec.js"
+    ]
+  },
+  "dependencies": {
+    "js2xmlparser": "^3.0.0",
+    "uuid": "^11.1.1",
+    "xml2js": "^0.6.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.7.0",
+    "globals": "^17.7.0",
+    "jest": "^30.4.2"
+  }
+}

package/src/base-request.js

@@ -0,0 +1,81 @@
+const { v5: uuidv5 } = require('uuid');
+
+module.exports.getSoapHeaderRequest = function (_params) {
+    if (!_params['message_id']) _params['message_id'] = uuidv5.URL;
+
+    var header = {
+        '@': {
+            'xmlns:s': 'http://www.w3.org/2003/05/soap-envelope',
+            'xmlns:wsa': 'http://schemas.xmlsoap.org/ws/2004/08/addressing',
+            'xmlns:wsen': 'http://schemas.xmlsoap.org/ws/2004/09/enumeration',
+            'xmlns:wsman': 'http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd',
+
+            'xmlns:p': 'http://schemas.microsoft.com/wbem/wsman/1/wsman.xsd',
+            'xmlns:rsp': 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell'
+        },
+        's:Header': {
+            'wsa:To': 'http://windows-host:5985/wsman',
+
+            'wsman:ResourceURI': {
+                '@': {
+                    'mustUnderstand': 'true'
+                },
+                '#': _params['resource_uri'] || 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/cmd'
+            },
+            'wsa:ReplyTo': {
+                'wsa:Address': {
+                    '@': {
+                        'mustUnderstand': 'true'
+                    },
+                    '#': 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous'
+                }
+            },
+            'wsman:MaxEnvelopeSize': {
+                '@': {
+                    'mustUnderstand': 'true'
+                },
+                '#': '153600'
+            },
+            'wsa:MessageID': 'uuid:' + _params['message_id'],
+            'wsman:Locale': {
+                '@': {
+                    'mustUnderstand': 'false',
+                    'xml:lang': 'en-US'
+                }
+            },
+            'wsman:OperationTimeout': _params['operationTimeout'] || 'PT60S',
+            'wsa:Action': {
+                '@': {
+                    'mustUnderstand': 'true'
+                },
+                '#': _params['action']
+            }
+        },
+    };
+    if (_params['shellId']) {
+        header['s:Header']['wsman:SelectorSet'] = [];
+        header['s:Header']['wsman:SelectorSet'].push({
+            'wsman:Selector': [{
+                '@': {
+                    'Name': 'ShellId'
+                },
+                '#': _params['shellId']
+            }]
+        });
+    }
+    if (_params['selectorSet']) {
+        header['s:Header']['wsman:SelectorSet'] = [];
+        for (const [key, value] of Object.entries(_params['selectorSet'])) {
+            header['s:Header']['wsman:SelectorSet'].push({
+                'wsman:Selector': [{
+                    '@': {
+                        'Name': key
+                    },
+                    '#': value
+                }]
+            });
+        }
+    }
+
+    return header;
+};

package/src/command.js

@@ -0,0 +1,208 @@
+const js2xmlparser = require('js2xmlparser');
+let winrm_soap_req = require('./base-request.js');
+let winrm_http_req = require('./http.js');
+let util = require('./util.js');
+
+function constructRunCommandRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'action': 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/Command',
+        'shellId': _params.shellId,
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Header']['wsman:OptionSet'] = [];
+    res['s:Header']['wsman:OptionSet'].push({
+        'wsman:Option': [{
+                '@': {
+                    'Name': 'WINRS_CONSOLEMODE_STDIN'
+                },
+                '#': 'TRUE'
+            },
+            {
+                '@': {
+                    'Name': 'WINRS_SKIP_CMD_SHELL'
+                },
+                '#': 'FALSE'
+            }
+        ]
+    });
+    res['s:Body'] = {
+        'rsp:CommandLine': {
+            'rsp:Command': _params.command
+        }
+    };
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+function constructReceiveRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'action': 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/Receive',
+        'shellId': _params.shellId,
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {
+        'rsp:Receive': {
+            'rsp:DesiredStream': {
+                '@': {
+                    'CommandId': _params.commandId
+                },
+                '#': 'stdout stderr'
+            }
+        }
+    };
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+function constructSignalRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'action': 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/Signal',
+        'shellId': _params.shellId,
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {
+        'rsp:Signal': [{
+            '@': {
+                'xmlns:rsp': 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell',
+                'CommandId': _params.commandId
+            },
+            'rsp:Code': `http://schemas.microsoft.com/wbem/wsman/1/windows/shell/signal/${_params.signal || 'ctrl_c'}`
+        }]
+    };
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+module.exports.doExecuteCommand = async function (_params) {
+    var req = constructRunCommandRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        var commandId = result['s:Envelope']['s:Body'][0]['rsp:CommandResponse'][0]['rsp:CommandId'][0];
+        return commandId;
+    }
+};
+
+function generatePowershellCommand(_params) {
+    var args = [];
+    args.unshift(
+        'powershell.exe',
+        '-NoProfile',
+        '-NonInteractive',
+        '-NoLogo',
+        '-ExecutionPolicy', 'Bypass',
+        '-InputFormat', 'Text',
+        '-Command', '"& {',
+        _params.command,
+        '; exit $LASTEXITCODE}"'
+    );
+    return args.join(' ');
+}
+
+module.exports.doExecutePowershell = async function (_params) {
+    _params['command'] = generatePowershellCommand(_params);
+    return this.doExecuteCommand(_params);
+};
+
+module.exports.doReceive = async function (_params) {
+    var req = constructReceiveRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        let response = {
+            commandState: undefined,
+            exitCode: undefined,
+            streams: []
+        };
+        if (result['s:Envelope']['s:Body'][0]['rsp:ReceiveResponse'][0]['rsp:Stream']) {
+            for (let stream of result['s:Envelope']['s:Body'][0]['rsp:ReceiveResponse'][0]['rsp:Stream']) {
+                let streamOutput = {};
+                streamOutput.name = stream['$'].Name;
+                if (Object.prototype.hasOwnProperty.call(stream['$'], 'End')) {
+                    streamOutput.end = true;
+                } else if (stream['_']) {
+                    streamOutput.data = Buffer.from(stream['_'], 'base64').toString('ascii');
+                }
+                response.streams.push(streamOutput);
+            }
+        }
+
+        if (result['s:Envelope']['s:Body'][0]['rsp:ReceiveResponse'][0]['rsp:CommandState']) {
+            let commandStateResponse = result['s:Envelope']['s:Body'][0]['rsp:ReceiveResponse'][0]['rsp:CommandState'][0];
+            response.commandState = (commandStateResponse['$'].State || '').match(/\/([a-zA-Z0-9]+)$/)[1];
+            response.exitCode = commandStateResponse['rsp:ExitCode'] && commandStateResponse['rsp:ExitCode'][0];
+        }
+
+        // NOTE: for use with doReceiveOutput (set here for consistency), use returned response.commandState/response.exitCode when available
+        _params.commandState = response.commandState;
+        _params.exitCode = response.exitCode;
+
+        return response;
+    }
+};
+
+module.exports.doReceiveOutput = async function (_params) {
+    let response = await module.exports.doReceive(_params);
+    if (response instanceof Error) {
+        return response;
+    }
+    let successOutput = '';
+    let failedOutput = '';
+    for (let stream of response.streams) {
+        if (stream.name === 'stdout' && !stream.end) {
+            successOutput += stream.data;
+        }
+        if (stream.name == 'stderr' && !stream.end) {
+            failedOutput += stream.data;
+        }
+    }
+    if (successOutput) {
+        return successOutput.trim();
+    }
+    return failedOutput.trim();
+};
+
+module.exports.doSignal = async function (_params) {
+    var req = constructSignalRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        return result['s:Envelope']['s:Body'][0]['rsp:SignalResponse'][0];
+    }
+};
+
+module.exports.doSignalInterrupt = async function (_params) {
+    return module.exports.doSignal(Object.assign({}, _params, { signal: 'ctrl_c' }));
+};
+
+module.exports.doSignalTerminate = async function (_params) {
+    return module.exports.doSignal(Object.assign({}, _params, { signal: 'terminate' }));
+};

package/src/enumerate.js

@@ -0,0 +1,213 @@
+const js2xmlparser = require('js2xmlparser');
+let winrm_soap_req = require('./base-request.js');
+let winrm_http_req = require('./http.js');
+let util = require('./util.js');
+
+function constructBeginEnumerationRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'resource_uri': _params.resourceUri || 'http://schemas.dmtf.org/wbem/wscim/1/*',
+        'action': 'http://schemas.xmlsoap.org/ws/2004/09/enumeration/Enumerate',
+        'selectorSet': _params.selectorSet,
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {
+        'wsen:Enumerate': [{
+            'wsen:NewContext': {},
+            'wsman:OptimizeEnumeration': [{}],
+            'wsen:MaxTime': _params.maxTime || 'PT60S',
+            'wsman:MaxElements': _params.maxElements || 20
+        }]
+    };
+
+    if (_params.filter) {
+        res['s:Body']['wsen:Enumerate'][0]['wsman:Filter'] = [{
+            '@': {
+              'Dialect': _params.filterDialect || 'http://www.w3.org/TR/1999/REC-xpath-19991116'
+            },
+            '#': _params.filter
+        }];
+    }
+
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+function constructPullEnumerationRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'resource_uri': _params.resourceUri || 'http://schemas.dmtf.org/wbem/wscim/1/*',
+        'action': 'http://schemas.xmlsoap.org/ws/2004/09/enumeration/Pull',
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {
+        'wsen:Pull': [{
+            'wsen:EnumerationContext': _params.enumerationId,
+            'wsen:MaxTime': _params.maxTime || 'PT10S',
+            'wsen:MaxElements': _params.maxElements || 20
+        }]
+    };
+
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+function constructReleaseEnumerationRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'resource_uri': _params.resourceUri || 'http://schemas.dmtf.org/wbem/wscim/1/*',
+        'action': 'http://schemas.xmlsoap.org/ws/2004/09/enumeration/Release',
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {
+        'wsen:Release': [{
+            'wsen:EnumerationContext': _params.enumerationId
+        }]
+    };
+
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+function unwrapPropertyValue(value, keepString) {
+    if (value && value['Datetime']) {
+        value = value['Datetime'][0];
+    }
+    if (value && value['$'] && value['$']['xsi:nil'] === 'true') {
+        value = null;
+    }
+    // keepString skips the numeric coercion for values that are strings by
+    // definition, where coercion mangles hex ("0xC000006D" -> 3221225581) and
+    // leading-zero values.
+    if (!keepString && typeof value === 'string' && !isNaN(value)) {
+        value = Number(value);
+    }
+    return value;
+}
+
+function getObjects(items, arrayProperties) {
+    // NOTE only suitable for objects structures like WMI, need additional handlers for other data types
+    if (!items) {
+        return [];
+    }
+    let arrayProps = new Set(arrayProperties || []);
+    let itemCollection = Object.values(items[0])[0];
+    let itemObjects = [];
+    for (let item of itemCollection) {
+        let itemObject = {};
+        for (let prop in item) {
+            if (prop === '$') { continue; }
+            let keyName = prop.replace(/^p:/, '');
+            let values = item[prop];
+            let value;
+            if (arrayProps.has(keyName)) {
+                // Caller-declared array property (e.g. Win32_NTLogEvent
+                // InsertionStrings): ALWAYS an array of raw strings, regardless
+                // of element count — the XML alone cannot distinguish a
+                // one-element array from a scalar, and string values must not
+                // be numerically coerced (hex/leading zeros).
+                value = values.map(v => unwrapPropertyValue(v, true));
+            } else if (values.length > 1) {
+                // Repeated XML elements are how WS-Man encodes multi-valued WMI
+                // properties — keep all values instead of only the first.
+                value = values.map(v => unwrapPropertyValue(v));
+            } else {
+                value = unwrapPropertyValue(values[0]);
+            }
+            itemObject[keyName] = value;
+        }
+        itemObjects.push(itemObject);
+    }
+    return itemObjects;
+}
+
+module.exports.doBeginEnumeration = async function (_params) {
+    var req = constructBeginEnumerationRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        var enumerationId = result['s:Envelope']['s:Body'][0]['n:EnumerateResponse'][0]['n:EnumerationContext'][0];
+        _params.enumerationId = enumerationId;
+
+        if (result['s:Envelope']['s:Body'][0]['n:EnumerateResponse'][0]['n:EndOfSequence']) {
+            _params.endOfSequence = true;
+        } else {
+            _params.endOfSequence = false;
+        }
+        let items = result['s:Envelope']['s:Body'][0]['n:EnumerateResponse'][0]['w:Items'];
+        return getObjects(items, _params.arrayProperties);
+    }
+};
+
+module.exports.doPullEnumeration = async function (_params) {
+    var req = constructPullEnumerationRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        if (result['s:Envelope']['s:Body'][0]['n:PullResponse'][0]['n:EndOfSequence']) {
+            _params.endOfSequence = true;
+        } else {
+            _params.endOfSequence = false;
+            _params.enumerationId = result['s:Envelope']['s:Body'][0]['n:PullResponse'][0]['n:EnumerationContext'][0];
+        }
+        let items = result['s:Envelope']['s:Body'][0]['n:PullResponse'][0]['n:Items'];
+        return getObjects(items, _params.arrayProperties);
+    }
+};
+
+module.exports.doReleaseEnumeration = async function (_params) {
+    var req = constructReleaseEnumerationRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        return 'success';
+    }
+};
+
+module.exports.doEnumerateAll = async function (_params) {
+    _params.endOfSequence = false;
+    var items = [];
+
+    var result = await module.exports.doBeginEnumeration(_params);
+    if (Array.isArray(result)) {
+        items.push(...result);
+    } else {
+        return result;
+    }
+
+    while (!_params.endOfSequence && _params.enumerationId) {
+        var pullResult = await module.exports.doPullEnumeration(_params);
+        if (Array.isArray(pullResult)) {
+            items.push(...pullResult);
+        } else {
+            // TODO attempt to release enumeration on error?
+            // TODO should we return partial successful items?
+            return pullResult;
+        }
+    }
+    return items;
+};

package/src/http.js

@@ -0,0 +1,82 @@
+const http = require('http');
+const https = require('https');
+const xml2jsparser = require('xml2js').parseString;
+
+const DEFAULT_TIMEOUT = 2 * 60 * 1000;
+
+module.exports.sendHttp = async function (_data, _host, _port, _path, _auth, _agent, _requestOptions) {
+    var xmlRequest = _data;
+    var options = {
+        agent: _agent,
+        host: _host,
+        port: _port,
+        path: _path,
+        method: 'POST',
+        timeout: DEFAULT_TIMEOUT
+    };
+    let headers = {
+        'Authorization': _auth,
+        'Content-Type': 'application/soap+xml;charset=UTF-8',
+        'User-Agent': 'NodeJS WinRM Client',
+        'Content-Length': Buffer.byteLength(xmlRequest)
+    };
+    if (!_auth) {
+        delete headers.Authorization;
+    }
+
+    // merge request options and headers
+    if (_requestOptions) {
+        Object.assign(options, _requestOptions);
+        headers = Object.assign(headers, _requestOptions.headers);
+    }
+    options.headers = headers;
+
+    let requestFn = options && options.protocol === 'https:' ? https.request : http.request;
+    return new Promise((resolve, reject) => {
+        var req = requestFn(options, (res) => {
+            if (res.statusCode < 200 || res.statusCode > 299 && res.statusCode != 500) {
+                reject(new Error('Failed to process the request, status Code: ' + res.statusCode));
+            }
+            res.setEncoding('utf8');
+            var dataBuffer = '';
+            res.on('data', (chunk) => {
+                dataBuffer += chunk;
+
+            });
+            res.on('end', () => {
+                if (!dataBuffer) {
+                    reject(new Error('Failed to process the request, status Code: ' + res.statusCode));
+                    return;
+                }
+                xml2jsparser(dataBuffer, (err, result) => {
+                    if (err) {
+                        reject(new Error('Data Parsing error', err));
+                    }
+                    resolve(result);
+                });
+            });
+
+        });
+
+        if (options.timeout > 0) {
+            // This is modelled on what the npm request library does with req timeouts
+            req.setTimeout(options.timeout, function () {
+                if (req) {
+                    req.abort();
+                    var e = new Error('ESOCKETTIMEDOUT');
+                    e.code = 'ESOCKETTIMEDOUT';
+                    e.connect = false;
+                    req.emit('error', e);
+                }
+            });
+        }
+        req.on('error', (err) => {
+            reject(err);
+        });
+        if (xmlRequest) {
+            req.write(xmlRequest);
+        }
+        req.end();
+
+    });
+};

package/src/invoke.js

@@ -0,0 +1,42 @@
+const js2xmlparser = require('js2xmlparser');
+let winrm_soap_req = require('./base-request.js');
+let winrm_http_req = require('./http.js');
+let util = require('./util.js');
+
+function constructInvokeActionRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'resource_uri': _params.resourceUri,
+        'action': _params.actionUri || (util.removeQueryString(_params.resourceUri) + '/' + _params.action),
+        'selectorSet': _params.selectorSet,
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {
+        [`p:${_params.action}_INPUT`]: [{
+            '@': {
+                'xmlns:p': util.removeQueryString(_params.resourceUri)
+            },
+            '#': _params.actionInput
+        }]
+    };
+
+    return js2xmlparser.parse('s:Envelope', res);
+}
+
+module.exports.doInvokeAction = async function (_params) {
+    var req = constructInvokeActionRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        return result['s:Envelope']['s:Body'][0][`p:${_params.action}_OUTPUT`][0];
+    }
+};

package/src/shell.js

@@ -0,0 +1,87 @@
+const js2xmlparser = require('js2xmlparser');
+let winrm_soap_req = require('./base-request.js');
+let winrm_http_req = require('./http.js');
+let util = require('./util.js');
+
+function constructCreateShellRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'action': 'http://schemas.xmlsoap.org/ws/2004/09/transfer/Create',
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Header']['wsman:OptionSet'] = [];
+    res['s:Header']['wsman:OptionSet'].push({
+        'wsman:Option': [{
+                '@': {
+                    'Name': 'WINRS_NOPROFILE'
+                },
+                '#': 'FALSE'
+            },
+            {
+                '@': {
+                    'Name': 'WINRS_CODEPAGE'
+                },
+                '#': '437'
+            }
+        ]
+    });
+    res['s:Body'] = {
+        'rsp:Shell': [{
+            'rsp:InputStreams': 'stdin',
+            'rsp:OutputStreams': 'stderr stdout'
+        }]
+    };
+    return js2xmlparser.parse('s:Envelope', res);
+
+}
+
+function constructDeleteShellRequest(_params) {
+    var res = winrm_soap_req.getSoapHeaderRequest({
+        'resource_uri': 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/cmd',
+        'action': 'http://schemas.xmlsoap.org/ws/2004/09/transfer/Delete',
+        'shellId': _params.shellId,
+        'operationTimeout': _params.operationTimeout
+    });
+
+    res['s:Body'] = {};
+    return js2xmlparser.parse('s:Envelope', res);
+
+}
+
+module.exports.doCreateShell = async function (_params) {
+    var req = constructCreateShellRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        var shellId = result['s:Envelope']['s:Body'][0]['rsp:Shell'][0]['rsp:ShellId'][0];
+        return shellId;
+    }
+};
+
+module.exports.doDeleteShell = async function (_params) {
+    var req = constructDeleteShellRequest(_params);
+
+    var auth = _params.auth;
+    if (_params.authOnce) {
+        auth = typeof _params.authOnce === 'string' ? _params.authOnce : _params.auth;
+        _params.auth = undefined;
+        _params.authOnce = undefined;
+    }
+    var result = await winrm_http_req.sendHttp(req, _params.host, _params.port, _params.path, auth, _params.agent, _params.requestOptions);
+
+    if (result['s:Envelope']['s:Body'][0]['s:Fault']) {
+        return new Error(util.faultFormatter(result['s:Envelope']['s:Body'][0]['s:Fault']));
+    } else {
+        //var output = result['s:Envelope']['s:Body'][0]['rsp:ReceiveResponse'][0]['rsp:Stream'];
+        return 'success';
+    }
+};

package/src/util.js

@@ -0,0 +1,20 @@
+module.exports.faultFormatter = function (faultElement) {
+    let faultCode = 'Unknown Fault';
+    let faultReason = '';
+
+    if (faultElement[0]['s:Code'] && faultElement[0]['s:Code'][0]['s:Subcode'] && faultElement[0]['s:Code'][0]['s:Subcode'][0]['s:Value']) {
+        faultCode = faultElement[0]['s:Code'][0]['s:Subcode'][0]['s:Value'];
+    }
+    if (faultElement[0]['s:Reason'] && faultElement[0]['s:Reason'][0]['s:Text'] && faultElement[0]['s:Reason'][0]['s:Text'][0]['_']) {
+        faultReason = faultElement[0]['s:Reason'][0]['s:Text'][0]['_'];
+    }
+
+    if (faultReason) {
+        return `${faultCode}: ${faultReason}`;
+    }
+    return `${faultCode}`;
+};
+
+module.exports.removeQueryString = function (uri) {
+    return uri && uri.replace(/\?.*$/, '');
+};

package/test/test.js

@@ -0,0 +1,13 @@
+var winrm = require('../index.js');
+
+async function performTest() {
+    try {
+        //var result = await winrm.runCommand('mkdir D:\\winrmtest001', '10.xxx.xxx.xxx', 5985, 'username', 'password');
+        var result = await winrm.runCommand('ipconfig /all', '10.xxx.xxx.xxx', 'username', 'password', 5985);
+        console.log(result);
+    } catch (error) {
+        console.error(`Exception Occurred: ${error}`);
+    }
+}
+
+performTest();