dsh-remote 0.8.49 → 0.8.51

package/node_modules/buildcheck/deps/Find-VisualStudio.cs

@@ -0,0 +1,250 @@
+// Copyright 2017 - Refael Ackermann
+// Distributed under MIT style license
+// See accompanying file LICENSE at https://github.com/node4good/windows-autoconf
+
+// Usage:
+// powershell -ExecutionPolicy Unrestricted -Command "Add-Type -Path Find-VisualStudio.cs; [VisualStudioConfiguration.Main]::PrintJson()"
+// This script needs to be compatible with PowerShell v2 to run on Windows 2008R2 and Windows 7.
+
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+
+namespace VisualStudioConfiguration
+{
+    [Flags]
+    public enum InstanceState : uint
+    {
+        None = 0,
+        Local = 1,
+        Registered = 2,
+        NoRebootRequired = 4,
+        NoErrors = 8,
+        Complete = 4294967295,
+    }
+
+    [Guid("6380BCFF-41D3-4B2E-8B2E-BF8A6810C848")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface IEnumSetupInstances
+    {
+
+        void Next([MarshalAs(UnmanagedType.U4), In] int celt,
+            [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Interface), Out] ISetupInstance[] rgelt,
+            [MarshalAs(UnmanagedType.U4)] out int pceltFetched);
+
+        void Skip([MarshalAs(UnmanagedType.U4), In] int celt);
+
+        void Reset();
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        IEnumSetupInstances Clone();
+    }
+
+    [Guid("42843719-DB4C-46C2-8E7C-64F1816EFD5B")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupConfiguration
+    {
+    }
+
+    [Guid("26AAB78C-4A60-49D6-AF3B-3C35BC93365D")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupConfiguration2 : ISetupConfiguration
+    {
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        IEnumSetupInstances EnumInstances();
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        ISetupInstance GetInstanceForCurrentProcess();
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        ISetupInstance GetInstanceForPath([MarshalAs(UnmanagedType.LPWStr), In] string path);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        IEnumSetupInstances EnumAllInstances();
+    }
+
+    [Guid("B41463C3-8866-43B5-BC33-2B0676F7F42E")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupInstance
+    {
+    }
+
+    [Guid("89143C9A-05AF-49B0-B717-72E218A2185C")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupInstance2 : ISetupInstance
+    {
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstanceId();
+
+        [return: MarshalAs(UnmanagedType.Struct)]
+        System.Runtime.InteropServices.ComTypes.FILETIME GetInstallDate();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstallationName();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstallationPath();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstallationVersion();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetDisplayName([MarshalAs(UnmanagedType.U4), In] int lcid);
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetDescription([MarshalAs(UnmanagedType.U4), In] int lcid);
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string ResolvePath([MarshalAs(UnmanagedType.LPWStr), In] string pwszRelativePath);
+
+        [return: MarshalAs(UnmanagedType.U4)]
+        InstanceState GetState();
+
+        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_UNKNOWN)]
+        ISetupPackageReference[] GetPackages();
+
+        ISetupPackageReference GetProduct();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetProductPath();
+
+        [return: MarshalAs(UnmanagedType.VariantBool)]
+        bool IsLaunchable();
+
+        [return: MarshalAs(UnmanagedType.VariantBool)]
+        bool IsComplete();
+
+        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_UNKNOWN)]
+        ISetupPropertyStore GetProperties();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetEnginePath();
+    }
+
+    [Guid("DA8D8A16-B2B6-4487-A2F1-594CCCCD6BF5")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupPackageReference
+    {
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetId();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetVersion();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetChip();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetLanguage();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetBranch();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetType();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetUniqueId();
+
+        [return: MarshalAs(UnmanagedType.VariantBool)]
+        bool GetIsExtension();
+    }
+
+    [Guid("c601c175-a3be-44bc-91f6-4568d230fc83")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupPropertyStore
+    {
+
+        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_BSTR)]
+        string[] GetNames();
+
+        object GetValue([MarshalAs(UnmanagedType.LPWStr), In] string pwszName);
+    }
+
+    [Guid("42843719-DB4C-46C2-8E7C-64F1816EFD5B")]
+    [CoClass(typeof(SetupConfigurationClass))]
+    [ComImport]
+    public interface SetupConfiguration : ISetupConfiguration2, ISetupConfiguration
+    {
+    }
+
+    [Guid("177F0C4A-1CD3-4DE7-A32C-71DBBB9FA36D")]
+    [ClassInterface(ClassInterfaceType.None)]
+    [ComImport]
+    public class SetupConfigurationClass
+    {
+    }
+
+    public static class Main
+    {
+        public static void PrintJson()
+        {
+            ISetupConfiguration query = new SetupConfiguration();
+            ISetupConfiguration2 query2 = (ISetupConfiguration2)query;
+            IEnumSetupInstances e = query2.EnumAllInstances();
+
+            int pceltFetched;
+            ISetupInstance2[] rgelt = new ISetupInstance2[1];
+            List<string> instances = new List<string>();
+            while (true)
+            {
+                e.Next(1, rgelt, out pceltFetched);
+                if (pceltFetched <= 0)
+                {
+                    Console.WriteLine(String.Format("[{0}]", string.Join(",", instances.ToArray())));
+                    return;
+                }
+
+                try
+                {
+                    instances.Add(InstanceJson(rgelt[0]));
+                }
+                catch (COMException)
+                {
+                    // Ignore instances that can't be queried.
+                }
+            }
+        }
+
+        private static string JsonString(string s)
+        {
+            return "\"" + s.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
+        }
+
+        private static string InstanceJson(ISetupInstance2 setupInstance2)
+        {
+            // Visual Studio component directory:
+            // https://docs.microsoft.com/en-us/visualstudio/install/workload-and-component-ids
+
+            StringBuilder json = new StringBuilder();
+            json.Append("{");
+
+            string path = JsonString(setupInstance2.GetInstallationPath());
+            json.Append(String.Format("\"path\":{0},", path));
+
+            string version = JsonString(setupInstance2.GetInstallationVersion());
+            json.Append(String.Format("\"version\":{0},", version));
+
+            List<string> packages = new List<string>();
+            foreach (ISetupPackageReference package in setupInstance2.GetPackages())
+            {
+                string id = JsonString(package.GetId());
+                packages.Add(id);
+            }
+            json.Append(String.Format("\"packages\":[{0}]", string.Join(",", packages.ToArray())));
+
+            json.Append("}");
+            return json.ToString();
+        }
+    }
+}

package/node_modules/buildcheck/lib/findvs.js

@@ -0,0 +1,361 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const { readFileSync, statSync } = require('fs');
+const { win32: path } = require('path');
+
+const modernMSBuildPath = (() => {
+  let arch;
+  switch (process.arch) {
+    case 'x64':
+      arch = 'amd64';
+      break;
+    case 'arm64':
+      arch = process.arch;
+      break;
+    default:
+      arch = '';
+  }
+  return path.join('MSBuild', 'Current', 'Bin', arch, 'MSBuild.exe');
+})();
+const VS_VERSIONS_MODERN = new Map([
+  [15, {
+    year: 2017,
+    msbuild: path.join('MSBuild', '15.0', 'Bin', 'MSBuild.exe'),
+    toolset: 'v141',
+  }],
+  [16, {
+    year: 2019,
+    msbuild: path.join('MSBuild', 'Current', 'Bin', 'MSBuild.exe'),
+    toolset: 'v142',
+  }],
+  [17, {
+    year: 2022,
+    msbuild: modernMSBuildPath,
+    toolset: 'v143',
+  }],
+  [18, {
+    year: 2026,
+    msbuild: modernMSBuildPath,
+    toolset: 'v145',
+  }],
+]);
+const PACKAGES = {
+  msbuild: /^Microsoft[.]VisualStudio[.]VC[.]MSBuild[.](?:v\d+[.])?Base$/i,
+  vctools: /^Microsoft[.]VisualStudio[.]Component[.]VC[.]Tools[.](x86[.]x64|ARM64)$/i,
+  express: /^Microsoft[.]VisualStudio[.]WDExpress$/i,
+  winsdk:
+    /^Microsoft[.]VisualStudio[.]Component[.]Windows(81|10|11)SDK(?:[.](\d+)(?:[.]Desktop.*)?)?$/,
+};
+const SDK_REG = 'HKLM\\Software\\Microsoft\\Microsoft SDKs\\Windows';
+const SDK32_REG =
+  'HKLM\\Software\\Wow6432Node\\Microsoft\\Microsoft SDKs\\Windows';
+
+function checkRequiredPackages(packages) {
+  if (!Array.isArray(packages))
+    return false;
+
+  let foundMSBuild = false;
+  let foundVCTools = false;
+  let foundExpress = false;
+  for (const pkg of packages) {
+    if (!foundMSBuild && PACKAGES.msbuild.test(pkg))
+      foundMSBuild = true;
+    else if (!foundVCTools && PACKAGES.vctools.test(pkg))
+      foundVCTools = true;
+    else if (!foundExpress && PACKAGES.express.test(pkg))
+      foundExpress = true;
+
+    if (foundMSBuild && (foundVCTools || foundExpress))
+      return true;
+  }
+}
+
+// Sorts newest to oldest
+function versionStringCompare(a, b) {
+  const splitA = a.split('.');
+  const splitB = b.split('.');
+  const len = Math.min(splitA.length, splitB.length);
+  for (let i = 0; i < len; ++i) {
+    const nA = parseInt(splitA[i], 10);
+    const nB = parseInt(splitB[i], 10);
+    if (nA > nB)
+      return -1;
+    if (nA < nB)
+      return 1;
+  }
+  if (splitA.length > splitB.length)
+    return -1;
+  else if (splitA.length < splitB.length)
+    return 1;
+  return 0;
+}
+
+function sdkVersionCompare(a, b) {
+  return versionStringCompare(a.fullVersion, b.fullVersion);
+}
+
+function getSDKPaths(fullVer) {
+  if (typeof fullVer !== 'string' || !fullVer)
+    return;
+  try {
+    const arch = (process.arch === 'ia32' ? 'x86' : process.arch);
+    const shortVer = `v${/^\d+[.]\d+/.exec(fullVer)[0]}`;
+    let verPath = getRegValue(`${SDK_REG}\\${shortVer}`, 'InstallationFolder');
+    if (!verPath)
+      verPath = getRegValue(`${SDK32_REG}\\${shortVer}`, 'InstallationFolder');
+    if (!verPath)
+      return;
+
+    // Includes
+    const includePaths = [];
+    for (const type of ['shared', 'um', 'ucrt']) {
+      const testPath = path.resolve(verPath, 'Include', fullVer, type);
+      statSync(testPath);
+      includePaths.push(testPath);
+    }
+
+    // Libraries
+    const libPaths = [];
+    for (const type of ['um', 'ucrt']) {
+      const testPath = path.resolve(verPath, 'Lib', fullVer, type, arch);
+      statSync(testPath);
+      libPaths.push(testPath);
+    }
+
+    return { includePaths, libPaths };
+  } catch {}
+}
+
+const execOpts = {
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'pipe'],
+  windowsHide: true,
+};
+
+function findModernVS() {
+  const versions = [];
+  const ps = path.join(
+    process.env.SystemRoot,
+    'System32',
+    'WindowsPowerShell',
+    'v1.0',
+    'powershell.exe'
+  );
+  const cs = path.resolve(__dirname, '..', 'deps', 'Find-VisualStudio.cs');
+  const args = [
+    '-ExecutionPolicy',
+    'Unrestricted',
+    '-NoProfile',
+    '-Command',
+    `&{Add-Type -Path '${cs}';[VisualStudioConfiguration.Main]::PrintJson()}`
+  ];
+  try {
+    const out = execFileSync(ps, args, execOpts);
+    const info = JSON.parse(out);
+    if (Array.isArray(info)) {
+      for (const vs of info) {
+        const vsPath = path.resolve(vs.path);
+        let vsVer = /^(?<major>\d+)[.](?<minor>\d+)[.]/.exec(vs.version);
+        if (!vsVer)
+          continue;
+        vsVer = {
+          full: vs.version,
+          major: +vsVer.groups.major,
+          minor: +vsVer.groups.minor,
+        };
+        const verInfo = VS_VERSIONS_MODERN.get(vsVer.major);
+        if (verInfo === undefined)
+          continue;
+        if (!checkRequiredPackages(vs.packages))
+          continue;
+        const vsSDKs = [];
+        for (const pkg of vs.packages) {
+          let fullVersion;
+          let version;
+          const m = PACKAGES.winsdk.exec(pkg);
+          if (!m)
+            continue;
+          const sdk = m[1];
+          switch (sdk) {
+            case '81':
+              fullVersion = version = '8.1';
+              break;
+            case '10':
+            case '11': {
+              if (m[2] === undefined)
+                continue;
+              const sdkVer = parseInt(m[2], 10);
+              if (!isFinite(sdkVer) || sdkVer < 0)
+                continue;
+              fullVersion = `10.0.${sdkVer}.0`;
+              version = '10.0';
+              break;
+            }
+          }
+          const paths = getSDKPaths(fullVersion);
+          if (!paths)
+            continue;
+          vsSDKs.push({
+            version,
+            fullVersion,
+            ...paths,
+          });
+        }
+        if (vsSDKs.length === 0)
+          continue;
+        let clPath;
+        const includePaths = [];
+        const libPaths = [];
+        try {
+          let vcVerFile;
+          let clVer;
+          try {
+            vcVerFile = path.join(
+              vsPath,
+              'VC',
+              'Auxiliary',
+              'Build',
+              `Microsoft.VCToolsVersion.${verInfo.toolset}.default.txt`
+            );
+            clVer = readFileSync(vcVerFile, { encoding: 'utf8' }).trim();
+          } catch {}
+          if (!clVer) {
+            vcVerFile = path.join(
+              vsPath,
+              'VC',
+              'Auxiliary',
+              'Build',
+              'Microsoft.VCToolsVersion.default.txt'
+            );
+            clVer = readFileSync(vcVerFile, { encoding: 'utf8' }).trim();
+          }
+          const arch = (process.arch === 'ia32' ? 'x86' : process.arch);
+          let testPath = path.join(
+            vsPath,
+            'VC',
+            'Tools',
+            'MSVC',
+            clVer,
+            'bin',
+            `Host${arch}`,
+            arch,
+            'cl.exe'
+          );
+          statSync(testPath);
+          clPath = testPath;
+
+          testPath = path.join(
+            vsPath,
+            'VC',
+            'Tools',
+            'MSVC',
+            clVer,
+            'include'
+          );
+          statSync(testPath);
+          includePaths.push(testPath);
+
+          testPath = path.join(
+            vsPath,
+            'VC',
+            'Tools',
+            'MSVC',
+            clVer,
+            'lib',
+            arch
+          );
+          statSync(testPath);
+          libPaths.push(testPath);
+        } catch {
+          continue;
+        }
+        vsSDKs.sort(sdkVersionCompare);
+        versions.push({
+          path: vsPath,
+          version: vsVer,
+          sdks: vsSDKs,
+          ...verInfo,
+          msbuild: path.join(vsPath, verInfo.msbuild),
+          cl: clPath,
+          includePaths,
+          libPaths,
+        });
+      }
+    }
+  } catch {}
+  return versions;
+}
+
+const VS_VERSIONS_OLDER = [
+  {
+    version: { full: '12.0', major: 12, minor: 0 },
+    year: 2013,
+    toolset: 'v120',
+  },
+  {
+    version: { full: '14.0', major: 14, minor: 0 },
+    year: 2015,
+    toolset: 'v140',
+  },
+];
+
+const VC_REG = 'HKLM\\Software\\Microsoft\\VisualStudio\\SxS\\VC7';
+const VC32_REG =
+  'HKLM\\Software\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VC7';
+const MSBUILD_REG = 'HKLM\\Software\\Microsoft\\MSBuild\\ToolsVersions';
+
+function getRegValue(key, value, use32) {
+  const extraArgs = (use32 ? [ '/reg:32' ] : []);
+  const regexp = new RegExp(`^\\s+${value}\\s+REG_\\w+\\s+(\\S.*)$`, 'im');
+  const reg = path.join(process.env.SystemRoot, 'System32', 'reg.exe');
+  const args = [ 'query', key, '/v', value, ...extraArgs ];
+
+  try {
+    const out = execFileSync(reg, args, execOpts);
+    const m = regexp.exec(out);
+    if (m)
+      return m[1];
+  } catch {}
+}
+
+function findOlderVS() {
+  const versions = [];
+  try {
+    for (const vs of VS_VERSIONS_OLDER) {
+      let vsPath = getRegValue(VC_REG, vs.version.full);
+      if (!vsPath)
+        vsPath = getRegValue(VC32_REG, vs.version.full);
+      if (!vsPath)
+        continue;
+      vsPath = path.resolve(vsPath, '..');
+
+      const msbuildPath = getRegValue(
+        `${MSBUILD_REG}\\${vs.version.full}`,
+        'MSBuildToolsPath',
+        (process.arch === 'ia32')
+      );
+      if (!msbuildPath)
+        continue;
+      versions.push({
+        path: vsPath,
+        ...vs,
+        msbuild: path.join(msbuildPath, 'MSBuild.exe'),
+        cl: path.join(vsPath, 'VC', 'bin', 'cl.exe'),
+        includePaths: [path.join(vsPath, 'VC', 'include')],
+        libPaths: [path.join(vsPath, 'VC', 'lib')],
+        sdks: [],
+      });
+    }
+  } catch {}
+  return versions;
+}
+
+module.exports = () => {
+  const versions = findModernVS().concat(findOlderVS());
+  // Sorts newest to oldest
+  versions.sort((a, b) => {
+    return versionStringCompare(a.version.full, b.version.full);
+  });
+  return versions;
+};